cont

Author: DylanAdlard

src/catomatic/BinaryCatalogue.py

@@ -27,7 +27,7 @@ class BinaryBuilder(PiezoExporter):
                                   Required columns: ['UNIQUEID', 'MUTATION']
                                   Optional columns: ['FRS']
 
-        FRS (float, optional): The Fraction Read Support threshold used to construct the catalogues.
+        frs (float, optional): The Fraction Read Support threshold used to construct the catalogues.
                                Lower FRS values allow for greater genotype heterogeneity.
 
         seed (list) optional): A list of predefined GARC neutral mutations with associated phenotypes
@@ -140,10 +140,36 @@ def build(
         # If no more susceptible solos, classify all R and U solos in one, final sweep
         self.classify(self.samples, self.mutations)
 
+        # add in rows for mutations without solos
+        # self.add_missing()
+
         self.order_catalogue()
 
         return self
 
+    def add_missing(self):
+
+        # add in remaining mutations
+        all_muts = set(self.mutations.MUTATION.dropna().unique())
+        classified_muts = set(self.catalogue.keys())
+        missing = all_muts - classified_muts
+
+        for mut in missing:
+            full_x = self.build_full_contingency(self.samples, self.mutations, mut)
+
+            proportion = self.calc_proportion(full_x)
+            ci = self.calc_confidence_interval(full_x)
+
+            data = {
+                "proportion": proportion,
+                "confidence": ci,
+                "full_contingency": full_x,
+                "solo_contingency": None,  # explicitly absent
+                "note": "No solo evidence; added post hoc",
+            }
+
+            self.add_mutation(mut, "U", data)
+
     def classify(self, samples: pd.DataFrame, mutations: pd.DataFrame) -> None:
         """
         Orchestrate one classification iteration over exposed 'solo' mutations.
@@ -196,22 +222,26 @@ def _process_solos(self, solos: pd.DataFrame, mut: str) -> None:
         # Skip mutations with fewer than min_count samples
         if solos[solos.MUTATION == mut].shape[0] < self.min_count:
             return
-        # build a contingency table
-        x, ids = self.build_contingency(solos, mut)
+        # build a contingency table for solo mutations
+        x, ids = self.build_solo_contingency(solos, mut)
+        # build a contingency table for all observations
+        full_x = self.build_full_contingency(self.samples, self.mutations, mut)
         # temporarily store mutation groups:
         self.temp_ids = ids
 
         # classify susceptible variants according to specified test mode
         if self.test is None:
-            self.skeleton_build(mut, x)
+            self.skeleton_build(mut, x, full_x)
         elif self.test == "Binomial":
-            self.binomial_build(mut, x)
+            self.binomial_build(mut, x, full_x)
         elif self.test == "Fisher":
-            self.fishers_build(mut, x)
+            self.fishers_build(mut, x, full_x)
         else:
             raise ValueError(f"Unknown test mode: {self.test}")
 
-    def skeleton_build(self, mutation: str, x: Contingency) -> None:
+    def skeleton_build(
+        self, mutation: str, x: Contingency, full_x: Contingency
+    ) -> None:
         """
         Record descriptive statistics and optionally mark susceptible solos.
         Calls homogenous susceptible S.
@@ -227,7 +257,12 @@ def skeleton_build(self, mutation: str, x: Contingency) -> None:
         proportion = self.calc_proportion(x)
         ci = self.calc_confidence_interval(x)
 
-        data = {"proportion": proportion, "confidence": ci, "contingency": x}
+        data = {
+            "proportion": proportion,
+            "confidence": ci,
+            "solo_contingency": x,
+            "contingency": full_x,
+        }
 
         if self.run_iter:
             # if iteratively classifing S variants
@@ -238,8 +273,12 @@ def skeleton_build(self, mutation: str, x: Contingency) -> None:
             # not phenotyping, just adding to catalogue
             self.add_mutation(mutation, "U", data)
 
-    def binomial_build(self, mutation: str, x: Contingency) -> None:
-        assert self.background is not None, "background must be provided for Binomial test"
+    def binomial_build(
+        self, mutation: str, x: Contingency, full_x: Contingency
+    ) -> None:
+        assert (
+            self.background is not None
+        ), "background must be provided for Binomial test"
         bg: float = float(self.background)
 
         # p-value function for binomial
@@ -258,10 +297,11 @@ def susceptible_rule(proportion: float, p_calc: float, x) -> bool:
         def resistant_rule(proportion: float, p_calc: float, x) -> bool:
             return bool(proportion > bg)
 
-        self.hypothesis_test(mutation, x, pvalue_fn, susceptible_rule, resistant_rule)
-
+        self.hypothesis_test(
+            mutation, x, full_x, pvalue_fn, susceptible_rule, resistant_rule
+        )
 
-    def fishers_build(self, mutation: str, x: Contingency) -> None:
+    def fishers_build(self, mutation: str, x: Contingency, full_x: Contingency) -> None:
         """
         Classify mutation using Fisher's exact test and directional inference.
 
@@ -291,12 +331,15 @@ def resistant_rule(proportion, p_calc, x) -> bool:
             odds = self.calc_odds_ratio(x)
             return odds > 1
 
-        self.hypothesis_test(mutation, x, pvalue_fn, susceptible_rule, resistant_rule)
+        self.hypothesis_test(
+            mutation, x, full_x, pvalue_fn, susceptible_rule, resistant_rule
+        )
 
     def hypothesis_test(
         self,
         mutation: str,
         x: Contingency,
+        full_x: Contingency,
         pvalue_fn: Callable[[Contingency], float],
         susceptible_rule: Callable[[float, float, Contingency], bool],
         resistant_rule: Callable[[float, float, Contingency], bool],
@@ -324,7 +367,8 @@ def hypothesis_test(
             "proportion": proportion,
             "confidence": ci,
             "p_value": p_calc,
-            "contingency": x,
+            "solo_contingency": x,  # solo-based (classification)
+            "contingency": full_x,  #         (descriptive only)
         }
 
         # ITERATIVE MODE (we actively try to find susceptibles)
@@ -414,7 +458,7 @@ def calc_confidence_interval(self, x: Contingency) -> Tuple[float, float]:
         return (lower, upper)
 
     @staticmethod
-    def build_contingency(
+    def build_solo_contingency(
         solos: pd.DataFrame, mutation: str
     ) -> Tuple[list[list[int]], list[str]]:
         """
@@ -438,6 +482,30 @@ def build_contingency(
 
         return [[R_count, S_count], [R_count_no_mut, S_count_no_mut]], ids
 
+    @staticmethod
+    def build_full_contingency(
+        samples: pd.DataFrame, mutations: pd.DataFrame, mutation: str
+    ) -> list[list[int]]:
+        """
+        Full contingency using ALL samples (sample-level, not row-level).
+        """
+
+        # determine which samples have the mutation
+        mut_present = mutations[mutations.MUTATION == mutation][
+            "UNIQUEID"
+        ].drop_duplicates()
+
+        df = samples.copy()
+        df["has_mut"] = df["UNIQUEID"].isin(mut_present)
+
+        R_with = ((df.PHENOTYPE == "R") & (df.has_mut)).sum()
+        S_with = ((df.PHENOTYPE == "S") & (df.has_mut)).sum()
+
+        R_without = ((df.PHENOTYPE == "R") & (~df.has_mut)).sum()
+        S_without = ((df.PHENOTYPE == "S") & (~df.has_mut)).sum()
+
+        return [[int(R_with), int(S_with)], [int(R_without), int(S_without)]]
+
     @staticmethod
     def calc_odds_ratio(x: Contingency) -> float:
         """

src/tests/test_BuildBinaryCatalogue.py

@@ -127,15 +127,15 @@ def test_add_mutation(builder):
     assert builder.catalogue[mutation]["evid"] == evidence
 
 
-def test_build_contingency(solo_data):
+def test_build_solo_contingency(solo_data):
     # for R + S
-    x_mut1 = BinaryBuilder.build_contingency(solo_data, "gene@A1S")[0]
+    x_mut1 = BinaryBuilder.build_solo_contingency(solo_data, "gene@A1S")[0]
     assert x_mut1 == [[1, 1], [3, 1]]
     # for R
-    x_mut2 = BinaryBuilder.build_contingency(solo_data, "gene@A2S")[0]
+    x_mut2 = BinaryBuilder.build_solo_contingency(solo_data, "gene@A2S")[0]
     assert x_mut2 == [[0, 1], [3, 1]]
     # For non-existent mutation - although should be filtered out beforehand
-    x_mut4 = BinaryBuilder.build_contingency(solo_data, "gene@A4S")[0]
+    x_mut4 = BinaryBuilder.build_solo_contingency(solo_data, "gene@A4S")[0]
     assert x_mut4 == [[0, 0], [3, 1]]
 
 
@@ -149,7 +149,7 @@ def test_calc_proportion():
     for x, expected in x_tests:
         assert (
             BinaryBuilder.calc_proportion(x) == expected
-        ), f"Failed for contingency {x}"
+        ), f"Failed for solo_contingency {x}"
 
 
 def test_calc_odds_ratio():
@@ -162,7 +162,7 @@ def test_calc_odds_ratio():
     for x, expected in x_tests:
         assert (
             BinaryBuilder.calc_odds_ratio(x) == expected
-        ), f"Failed for contingency {x}"
+        ), f"Failed for solo_contingency {x}"
 
 
 @pytest.mark.parametrize("builder", [{"p": 0.95}], indirect=True)
@@ -178,7 +178,7 @@ def test_calc_confidence_interval(builder):
         ci = builder.calc_confidence_interval(x)
         ci = [round(ci[0], 4), round(ci[1], 4)]
 
-        assert ci == expected, f"Failed for contingency {x}"
+        assert ci == expected, f"Failed for solo_contingency {x}"
 
 
 @pytest.mark.parametrize("builder", [{"p": 0.95}], indirect=True)
@@ -188,8 +188,9 @@ def test_skeleton_build(builder):
     # now test addition when run_iter = False
     mutation = "mut4"
     x = [[27, 21], [3, 22]]
+    full_x = [[0, 0], [0,0]]
 
-    builder.skeleton_build(mutation, x)
+    builder.skeleton_build(mutation, x, full_x)
     # check its actually been added
     assert mutation in builder.catalogue
     # check if the correct phenotype has been added
@@ -198,7 +199,8 @@ def test_skeleton_build(builder):
     expected_e = {
         "proportion": builder.calc_proportion(x),
         "confidence": builder.calc_confidence_interval(x),
-        "contingency": x,
+        "solo_contingency": x,
+        "contingency": full_x,
     }
 
     assert builder.catalogue[mutation]["evid"] == expected_e
@@ -218,6 +220,7 @@ def test_binomial_build_RU(builder):
         ([[27, 21], [3, 22]], "R"),
         ([[5, 21], [3, 22]], "U"),
     ]
+    full_x = [[0, 0], [0, 0]]
 
     for mut in range(len(mutations)):
         mutation = mutations[mut]
@@ -232,20 +235,21 @@ def test_binomial_build_RU(builder):
             "proportion": builder.calc_proportion(x),
             "confidence": builder.calc_confidence_interval(x),
             "p_value": p_expected,
-            "contingency": x,
+            "solo_contingency": x,
+            "contingency": full_x
         }
 
-        builder.binomial_build(mutation, x)
+        builder.binomial_build(mutation, x, full_x)
         # make sure mutaiton was added
-        assert mutation in builder.catalogue, f"Failed for contingency {x}"
+        assert mutation in builder.catalogue, f"Failed for solo_contingency {x}"
         # make sure phenotype was determined correclty
         assert (
             builder.catalogue[mutation]["pred"] == phenotype
-        ), f"Failed for contingency {x}"
+        ), f"Failed for solo_contingency {x}"
         # make sure evidence was added correclty
         assert (
             builder.catalogue[mutation]["evid"] == expected_e
-        ), f"Failed for contingency {x}"
+        ), f"Failed for solo_contingency {x}"
 
         # fyi haven't tested entire decision tree for run_iter=True, but they're are almost identical
 
@@ -264,6 +268,7 @@ def test_fisher_build_RU(builder):
         ([[27, 21], [3, 22]], "R"),
         ([[5, 21], [3, 22]], "U"),
     ]
+    full_x = [[0, 0], [0, 0]]
 
     for mut in range(len(mutations)):
         mutation = mutations[mut]
@@ -276,20 +281,21 @@ def test_fisher_build_RU(builder):
             "proportion": builder.calc_proportion(x),
             "confidence": builder.calc_confidence_interval(x),
             "p_value": p_expected,
-            "contingency": x,
+            "solo_contingency": x,
+            "contingency": full_x
         }
 
-        builder.fishers_build(mutation, x)
+        builder.fishers_build(mutation, x, full_x)
         # make sure mutaiton was added
-        assert mutation in builder.catalogue, f"Failed for contingency {x}"
+        assert mutation in builder.catalogue, f"Failed for solo_contingency {x}"
         # make sure phenotype was determined correclty
         assert (
             builder.catalogue[mutation]["pred"] == phenotype
-        ), f"Failed for contingency {x}"
+        ), f"Failed for solo_contingency {x}"
         # make sure evidence was added correclty
         assert (
             builder.catalogue[mutation]["evid"] == expected_e
-        ), f"Failed for contingency {x}"
+        ), f"Failed for solo_contingency {x}"
 
 
 # the S tests below are conceptually more complex than the RU tests, as these use the