phykit 2.1.71__tar.gz → 2.1.73__tar.gz

{phykit-2.1.71 → phykit-2.1.73}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phykit
-Version: 2.1.71
+Version: 2.1.73
 Home-page: https://github.com/jlsteenwyk/phykit
 Author: Jacob L. Steenwyk
 Author-email: jlsteenwyk@gmail.com

{phykit-2.1.71 → phykit-2.1.73}/phykit/cli_registry.py

@@ -188,6 +188,8 @@ ALIAS_TO_HANDLER: Dict[str, str] = {
     "da": "discordance_asymmetry",
     "spec_disc": "spectral_discordance",
     "sd": "spectral_discordance",
+    "impute": "phylo_impute",
+    "phylo_imp": "phylo_impute",
     "trait_correlation": "trait_correlation",
     "trait_corr": "trait_correlation",
     "phylo_corr": "trait_correlation",

{phykit-2.1.71 → phykit-2.1.73}/phykit/phykit.py

@@ -227,6 +227,9 @@ class Phykit:
                 trait_correlation (alias: trait_corr; phylo_corr)
                     - compute phylogenetic correlations between all pairs
                       of traits and display as a heatmap
+                phylo_impute (alias: impute; phylo_imp)
+                    - impute missing trait values using phylogenetic
+                      relationships and between-trait correlations
                 phylogenetic_ordination (alias: phylo_ordination; ordination; ord;
                     phylo_pca; phyl_pca; ppca; phylo_dimreduce; dimreduce; pdr)
                     - phylogenetic ordination (PCA, t-SNE, or UMAP) on
@@ -3681,6 +3684,73 @@ class Phykit:
         _add_json_argument(parser)
         _run_service(parser, argv, TraitCorrelation)
 
+    @staticmethod
+    def phylo_impute(argv):
+        parser = _new_parser(
+            description=textwrap.dedent(
+                f"""\
+                {help_header}
+
+                Phylogenetic imputation of missing trait values using
+                conditional multivariate normal distributions.
+
+                Captures both phylogenetic relationships (via the
+                tree's variance-covariance matrix) and between-trait
+                correlations to predict missing values. Reports
+                imputed values with standard errors and 95% CIs.
+
+                Missing values in the input trait file may be marked
+                as NA, na, ?, or left empty.
+
+                Input is a phylogenetic tree and a tab-delimited
+                multi-trait file with a header row:
+                taxon<tab>trait1<tab>trait2<tab>...
+
+                Aliases:
+                  phylo_impute, impute, phylo_imp
+                Command line interfaces:
+                  pk_phylo_impute, pk_impute, pk_phylo_imp
+
+                Usage:
+                phykit phylo_impute -t <tree> -d <trait_data> -o <output>
+                  [-g <gene_trees>] [--json]
+
+                Options
+                =====================================================
+                -t/--tree                   tree file (required)
+
+                -d/--trait-data             multi-trait TSV with header
+                                            row; missing values marked
+                                            as NA, ?, or empty
+                                            (required)
+
+                -o/--output                 output TSV file with
+                                            imputed values (required)
+
+                -g/--gene-trees             optional multi-Newick file
+                                            of gene trees for
+                                            discordance-aware VCV
+
+                --json                      optional argument to output
+                                            results as JSON
+                """
+            ),
+        )
+        parser.add_argument(
+            "-t", "--tree", type=str, required=True, help=SUPPRESS, metavar=""
+        )
+        parser.add_argument(
+            "-d", "--trait-data", type=str, required=True, help=SUPPRESS, metavar=""
+        )
+        parser.add_argument(
+            "-o", "--output", type=str, required=True, help=SUPPRESS, metavar=""
+        )
+        parser.add_argument(
+            "-g", "--gene-trees", type=str, default=None, help=SUPPRESS, metavar=""
+        )
+        _add_json_argument(parser)
+        _run_service(parser, argv, PhyloImpute)
+
     @staticmethod
     def phylogenetic_ordination(argv):
         parser = _new_parser(
@@ -5751,8 +5821,8 @@ class Phykit:
         parser.add_argument(
             "--missing-taxa",
             type=str,
-            choices=["error", "shared"],
-            default="error",
+            choices=["allow", "error", "shared"],
+            default="allow",
             required=False,
             help=SUPPRESS,
         )
@@ -8562,5 +8632,9 @@ def tree_space(argv=None):
     Phykit.tree_space(sys.argv[1:])
 
 
+def phylo_impute(argv=None):
+    Phykit.phylo_impute(sys.argv[1:])
+
+
 def trait_rate_map(argv=None):
     Phykit.trait_rate_map(sys.argv[1:])

{phykit-2.1.71 → phykit-2.1.73}/phykit/service_factories.py

@@ -112,6 +112,7 @@ TreenessOverRCV = _LazyServiceFactory("phykit.services.tree.treeness_over_rcv",
 EvoTempoMap = _LazyServiceFactory("phykit.services.tree.evo_tempo_map", "EvoTempoMap")
 DiscordanceAsymmetry = _LazyServiceFactory("phykit.services.tree.discordance_asymmetry", "DiscordanceAsymmetry")
 SpectralDiscordance = _LazyServiceFactory("phykit.services.tree.spectral_discordance", "SpectralDiscordance")
+PhyloImpute = _LazyServiceFactory("phykit.services.tree.phylo_impute", "PhyloImpute")
 TraitCorrelation = _LazyServiceFactory("phykit.services.tree.trait_correlation", "TraitCorrelation")
 TraitRateMap = _LazyServiceFactory("phykit.services.tree.trait_rate_map", "TraitRateMap")
 TreeSpace = _LazyServiceFactory("phykit.services.tree.tree_space", "TreeSpace")

{phykit-2.1.71 → phykit-2.1.73}/phykit/services/tree/__init__.py

@@ -49,6 +49,7 @@ _EXPORTS = {
     "TreenessOverRCV": "treeness_over_rcv",
     "ConcordanceAsr": "concordance_asr",
     "PhyloLogistic": "phylo_logistic",
+    "PhyloImpute": "phylo_impute",
     "TraitCorrelation": "trait_correlation",
     "TraitRateMap": "trait_rate_map",
     "TreeSpace": "tree_space",

{phykit-2.1.71 → phykit-2.1.73}/phykit/services/tree/consensus_network.py

@@ -103,16 +103,29 @@ class ConsensusNetwork(Tree):
             raise PhykitUserError(
                 [
                     "Input trees do not share an identical taxon set.",
-                    "Use --missing-taxa shared to prune all trees to their shared taxa.",
+                    "Use --missing-taxa allow or --missing-taxa shared.",
                 ],
                 code=2,
             )
 
+        if self.missing_taxa == "allow":
+            # Use the union of all taxa; each tree contributes splits
+            # using its own taxon set. Split frequencies are normalized
+            # by how many trees could contain each split.
+            union_taxa = set.union(*tip_sets)
+            if len(union_taxa) < 3:
+                raise PhykitUserError(
+                    ["Fewer than 3 taxa found across all trees."], code=2
+                )
+            return trees, False, union_taxa
+
+        # shared mode
         if len(shared_taxa) < 3:
             raise PhykitUserError(
                 [
                     "Unable to compute network after pruning to shared taxa.",
                     "At least 3 shared taxa are required.",
+                    "Consider using --missing-taxa allow instead.",
                 ],
                 code=2,
             )
@@ -159,19 +172,80 @@ class ConsensusNetwork(Tree):
         return splits
 
     @staticmethod
-    def _count_splits(trees: List, all_taxa: frozenset) -> Counter:
+    def _count_splits(trees: List, all_taxa: frozenset,
+                      allow_mode: bool = False) -> Tuple[Counter, Counter]:
+        """Count splits across trees.
+
+        Returns (split_counts, split_possible) where split_possible[s]
+        is the number of trees that contain ALL taxa in split s (and
+        its complement). In allow mode, each tree uses its own taxon
+        set; in shared mode, all trees use all_taxa.
+        """
         counter = Counter()
-        for tree in trees:
-            tree_splits = ConsensusNetwork._extract_splits_from_tree(tree, all_taxa)
-            for split in tree_splits:
-                counter[split] += 1
-        return counter
+        possible = Counter()
+
+        if allow_mode:
+            # Precompute taxon sets for all trees
+            tree_taxa_list = [
+                frozenset(t.name for t in tree.get_terminals())
+                for tree in trees
+            ]
+
+            # Extract splits from each tree using its own taxon set
+            for tree, tree_taxa in zip(trees, tree_taxa_list):
+                tree_splits = ConsensusNetwork._extract_splits_from_tree(
+                    tree, tree_taxa
+                )
+                for split in tree_splits:
+                    counter[split] += 1
+
+            # For normalization: each split was found in counter[split]
+            # trees. The "possible" count is the number of trees that
+            # contain ALL taxa on both sides. Since we extracted each
+            # split from a tree that had all its taxa, the split count
+            # IS the possible count (a tree can only produce a split if
+            # it contains all the relevant taxa).
+            for split in counter:
+                possible[split] = counter[split]
+
+            # Actually, we should count how many trees COULD have
+            # produced the split but didn't. A more accurate approach:
+            # possible = number of trees containing all taxa in the
+            # split's smaller side. But since splits are defined
+            # relative to each tree's own taxon set, the split IS
+            # the canonical smaller side from that tree. Different
+            # trees may have different "all_taxa" so the same
+            # bipartition in two trees means different things.
+            #
+            # The simplest correct normalization for incomplete
+            # taxon sampling: frequency = count / n_trees.
+            # This is what most software does.
+            for split in counter:
+                possible[split] = len(trees)
+        else:
+            for tree in trees:
+                tree_splits = ConsensusNetwork._extract_splits_from_tree(
+                    tree, all_taxa
+                )
+                for split in tree_splits:
+                    counter[split] += 1
+            for split in counter:
+                possible[split] = len(trees)
+
+        return counter, possible
 
     @staticmethod
-    def _filter_splits(split_counts: Counter, n_trees: int, threshold: float) -> List[Tuple[frozenset, int, float]]:
+    def _filter_splits(
+        split_counts: Counter, n_trees: int, threshold: float,
+        split_possible: Counter = None,
+    ) -> List[Tuple[frozenset, int, float]]:
         results = []
         for split, count in split_counts.items():
-            freq = count / n_trees
+            if split_possible and split in split_possible:
+                denom = split_possible[split]
+            else:
+                denom = n_trees
+            freq = count / denom if denom > 0 else 0.0
             if freq >= threshold:
                 results.append((split, count, freq))
         results.sort(key=lambda x: (-x[2], sorted(x[0])))
@@ -435,8 +509,14 @@ class ConsensusNetwork(Tree):
         all_taxa = frozenset(all_taxa_set)
         n_trees = len(trees)
 
-        split_counts = self._count_splits(trees, all_taxa)
-        filtered = self._filter_splits(split_counts, n_trees, self.threshold)
+        allow_mode = (self.missing_taxa == "allow")
+        split_counts, split_possible = self._count_splits(
+            trees, all_taxa, allow_mode=allow_mode
+        )
+        filtered = self._filter_splits(
+            split_counts, n_trees, self.threshold,
+            split_possible=split_possible,
+        )
 
         if self.json_output:
             splits_list = [