phykit 2.1.46__tar.gz → 2.1.47__tar.gz

{phykit-2.1.46 → phykit-2.1.47}/PKG-INFO

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

{phykit-2.1.46 → phykit-2.1.47}/phykit/cli_registry.py

@@ -88,6 +88,8 @@ ALIAS_TO_HANDLER: Dict[str, str] = {
     "pgls": "phylogenetic_regression",
     "phylo_glm": "phylogenetic_glm",
     "pglm": "phylogenetic_glm",
+    "parsimony": "parsimony_score",
+    "pars": "parsimony_score",
     "pic": "independent_contrasts",
     "phylo_contrasts": "independent_contrasts",
     "asr": "ancestral_state_reconstruction",

{phykit-2.1.46 → phykit-2.1.47}/phykit/phykit.py

@@ -163,6 +163,8 @@ class Phykit:
                 ===================
                 independent_contrasts (alias: pic; phylo_contrasts)
                     - Felsenstein's phylogenetically independent contrasts
+                parsimony_score (alias: parsimony; pars)
+                    - Fitch parsimony score of a tree given an alignment
                 ancestral_state_reconstruction (alias: asr; anc_recon)
                     - estimate ancestral states for continuous traits using
                       ML (fast or VCV-based) with optional contMap plot
@@ -1679,6 +1681,62 @@ class Phykit:
         _run_service(parser, argv, VariableSites)
 
     ## Tree functions
+    @staticmethod
+    def parsimony_score(argv):
+        parser = _new_parser(
+            description=textwrap.dedent(
+                f"""\
+                {help_header}
+
+                Compute the Fitch (1971) maximum parsimony score of a
+                tree given an alignment.
+
+                The parsimony score is the minimum number of character
+                state changes required to explain the alignment on the
+                given tree topology. Each site is scored independently
+                using the Fitch downpass algorithm.
+
+                Gap characters (-, N, X, ?) are treated as wildcards.
+                Multifurcations are automatically resolved.
+
+                Cross-validated against R's phangorn::parsimony().
+
+                Aliases:
+                  parsimony_score, parsimony, pars
+                Command line interfaces:
+                  pk_parsimony_score, pk_parsimony, pk_pars
+
+                Usage:
+                phykit parsimony_score -t <tree> -a <alignment>
+                  [-v/--verbose] [--json]
+
+                Options
+                =====================================================
+                -t/--tree                   tree file (required)
+
+                -a/--alignment              alignment file in FASTA
+                                            format (required)
+
+                -v/--verbose                print per-site parsimony
+                                            scores
+
+                --json                      optional argument to output
+                                            results as JSON
+                """
+            ),
+        )
+        parser.add_argument(
+            "-t", "--tree", type=str, required=True, help=SUPPRESS, metavar=""
+        )
+        parser.add_argument(
+            "-a", "--alignment", type=str, required=True, help=SUPPRESS, metavar=""
+        )
+        parser.add_argument(
+            "-v", "--verbose", action="store_true", required=False, help=SUPPRESS
+        )
+        _add_json_argument(parser)
+        _run_service(parser, argv, ParsimonyScore)
+
     @staticmethod
     def independent_contrasts(argv):
         parser = _new_parser(
@@ -6725,6 +6783,10 @@ def variable_sites(argv=None):
 
 
 # Tree-based functions
+def parsimony_score(argv=None):
+    Phykit.parsimony_score(sys.argv[1:])
+
+
 def independent_contrasts(argv=None):
     Phykit.independent_contrasts(sys.argv[1:])
 

{phykit-2.1.46 → phykit-2.1.47}/phykit/service_factories.py

@@ -83,6 +83,7 @@ RelativeRateTest = _LazyServiceFactory("phykit.services.tree.relative_rate_test"
 ThresholdModel = _LazyServiceFactory("phykit.services.tree.threshold_model", "ThresholdModel")
 PolytomyTest = _LazyServiceFactory("phykit.services.tree.polytomy_test", "PolytomyTest")
 PrintTree = _LazyServiceFactory("phykit.services.tree.print_tree", "PrintTree")
+ParsimonyScore = _LazyServiceFactory("phykit.services.tree.parsimony_score", "ParsimonyScore")
 PhyloHeatmap = _LazyServiceFactory("phykit.services.tree.phylo_heatmap", "PhyloHeatmap")
 PruneTree = _LazyServiceFactory("phykit.services.tree.prune_tree", "PruneTree")
 QuartetPie = _LazyServiceFactory("phykit.services.tree.quartet_pie", "QuartetPie")

{phykit-2.1.46 → phykit-2.1.47}/phykit/services/tree/__init__.py

@@ -27,6 +27,7 @@ _EXPORTS = {
     "RelativeRateTest": "relative_rate_test",
     "PolytomyTest": "polytomy_test",
     "PrintTree": "print_tree",
+    "ParsimonyScore": "parsimony_score",
     "PhyloHeatmap": "phylo_heatmap",
     "PruneTree": "prune_tree",
     "QuartetPie": "quartet_pie",

phykit-2.1.47/phykit/services/tree/parsimony_score.py

@@ -0,0 +1,169 @@
+"""
+Maximum parsimony score of a tree given an alignment.
+
+Computes the Fitch (1971) parsimony score — the minimum number of
+character state changes required to explain the alignment on the
+given tree topology. Each site is scored independently and the
+total is summed.
+
+Cross-validated against R's phangorn::parsimony().
+"""
+import copy
+from typing import Dict, List
+
+from Bio import SeqIO
+
+from .base import Tree
+from ...helpers.json_output import print_json
+from ...errors import PhykitUserError
+
+
+class ParsimonyScore(Tree):
+    def __init__(self, args) -> None:
+        parsed = self.process_args(args)
+        super().__init__(tree_file_path=parsed["tree_file_path"])
+        self.alignment_path = parsed["alignment_path"]
+        self.verbose = parsed["verbose"]
+        self.json_output = parsed["json_output"]
+
+    def run(self) -> None:
+        tree = self.read_tree_file()
+        tree = copy.deepcopy(tree)
+        self._validate_tree(tree)
+        self._resolve_polytomies(tree)
+
+        sequences = self._parse_alignment(self.alignment_path)
+
+        # Prune to shared taxa
+        tree_tips = set(t.name for t in tree.get_terminals())
+        seq_taxa = set(sequences.keys())
+        shared = tree_tips & seq_taxa
+        if len(shared) < 3:
+            raise PhykitUserError(
+                [
+                    f"Only {len(shared)} shared taxa between tree and alignment.",
+                    "At least 3 shared taxa are required.",
+                ],
+                code=2,
+            )
+
+        tips_to_prune = list(tree_tips - shared)
+        if tips_to_prune:
+            tree = self.prune_tree_using_taxa_list(tree, tips_to_prune)
+            self._resolve_polytomies(tree)
+
+        sequences = {t: sequences[t] for t in shared}
+        aln_length = len(next(iter(sequences.values())))
+
+        total_score, per_site = self._fitch_parsimony(tree, sequences, aln_length)
+
+        if self.json_output:
+            payload = {
+                "parsimony_score": total_score,
+                "alignment_length": aln_length,
+                "n_taxa": len(shared),
+            }
+            if self.verbose:
+                payload["per_site_scores"] = per_site
+            print_json(payload)
+        else:
+            print(total_score)
+            if self.verbose:
+                print()
+                for i, score in enumerate(per_site, 1):
+                    print(f"{i}\t{score}")
+
+    def process_args(self, args) -> Dict:
+        return dict(
+            tree_file_path=args.tree,
+            alignment_path=args.alignment,
+            verbose=getattr(args, "verbose", False),
+            json_output=getattr(args, "json", False),
+        )
+
+    def _validate_tree(self, tree) -> None:
+        tips = list(tree.get_terminals())
+        if len(tips) < 3:
+            raise PhykitUserError(
+                ["Tree must have at least 3 tips."], code=2
+            )
+
+    def _resolve_polytomies(self, tree) -> None:
+        from Bio.Phylo import Newick
+        for clade in tree.find_clades(order="postorder"):
+            while len(clade.clades) > 2:
+                child1 = clade.clades.pop()
+                child2 = clade.clades.pop()
+                new_internal = Newick.Clade(branch_length=0.0)
+                new_internal.clades = [child1, child2]
+                clade.clades.append(new_internal)
+
+    def _parse_alignment(self, path: str) -> Dict[str, str]:
+        try:
+            records = list(SeqIO.parse(path, "fasta"))
+        except Exception:
+            raise PhykitUserError(
+                [f"Could not parse alignment from {path}."], code=2
+            )
+        if not records:
+            raise PhykitUserError(
+                ["Alignment file is empty."], code=2
+            )
+        sequences = {r.id: str(r.seq).upper() for r in records}
+
+        # Validate same length
+        lengths = set(len(s) for s in sequences.values())
+        if len(lengths) > 1:
+            raise PhykitUserError(
+                ["Sequences have different lengths. Provide an aligned FASTA file."],
+                code=2,
+            )
+        return sequences
+
+    def _fitch_parsimony(
+        self, tree, sequences: Dict[str, str], aln_length: int
+    ) -> tuple:
+        """Compute Fitch parsimony score.
+
+        For each site, performs a postorder (downpass) traversal:
+        - Terminal nodes: state set = {observed character}
+        - Internal nodes: if children share states, intersection;
+          otherwise union (and add 1 to score)
+
+        Gap characters (-) and ambiguous characters (N, X, ?) are
+        treated as wildcards (matching any state).
+        """
+        wildcard_chars = {"-", "N", "X", "?", "n", "x"}
+        all_states = {"A", "C", "G", "T"}
+        per_site = []
+        total_score = 0
+
+        for site_idx in range(aln_length):
+            site_score = 0
+            node_states = {}
+
+            for clade in tree.find_clades(order="postorder"):
+                if clade.is_terminal():
+                    char = sequences[clade.name][site_idx]
+                    if char in wildcard_chars:
+                        node_states[id(clade)] = set(all_states)
+                    else:
+                        node_states[id(clade)] = {char}
+                else:
+                    if len(clade.clades) != 2:
+                        continue
+                    left, right = clade.clades
+                    left_states = node_states.get(id(left), set(all_states))
+                    right_states = node_states.get(id(right), set(all_states))
+
+                    intersection = left_states & right_states
+                    if intersection:
+                        node_states[id(clade)] = intersection
+                    else:
+                        node_states[id(clade)] = left_states | right_states
+                        site_score += 1
+
+            per_site.append(site_score)
+            total_score += site_score
+
+        return total_score, per_site

phykit-2.1.47/phykit/version.py

@@ -0,0 +1 @@
+__version__ = "2.1.47"

{phykit-2.1.46 → phykit-2.1.47}/phykit.egg-info/PKG-INFO

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

{phykit-2.1.46 → phykit-2.1.47}/phykit.egg-info/SOURCES.txt

@@ -84,6 +84,7 @@ phykit/services/tree/nearest_neighbor_interchange.py
 phykit/services/tree/network_signal.py
 phykit/services/tree/ou_shift_detection.py
 phykit/services/tree/ouwie.py
+phykit/services/tree/parsimony_score.py
 phykit/services/tree/patristic_distances.py
 phykit/services/tree/phenogram.py
 phykit/services/tree/phylo_heatmap.py

{phykit-2.1.46 → phykit-2.1.47}/phykit.egg-info/entry_points.txt

@@ -125,7 +125,10 @@ pk_pairwise_id = phykit.phykit:pairwise_identity
 pk_pairwise_identity = phykit.phykit:pairwise_identity
 pk_pal2nal = phykit.phykit:thread_dna
 pk_paqc = phykit.phykit:plot_alignment_qc
+pk_pars = phykit.phykit:parsimony_score
+pk_parsimony = phykit.phykit:parsimony_score
 pk_parsimony_informative_sites = phykit.phykit:parsimony_informative_sites
+pk_parsimony_score = phykit.phykit:parsimony_score
 pk_patristic_distances = phykit.phykit:patristic_distances
 pk_pd = phykit.phykit:patristic_distances
 pk_pdr = phykit.phykit:phylogenetic_ordination

{phykit-2.1.46 → phykit-2.1.47}/setup.py

@@ -101,6 +101,9 @@ setup(
             "pk_variable_sites = phykit.phykit:variable_sites",
             "pk_vs = phykit.phykit:variable_sites",
             "pk_ancestral_state_reconstruction = phykit.phykit:ancestral_state_reconstruction", # Tree-based functions
+            "pk_parsimony_score = phykit.phykit:parsimony_score",
+            "pk_parsimony = phykit.phykit:parsimony_score",
+            "pk_pars = phykit.phykit:parsimony_score",
             "pk_independent_contrasts = phykit.phykit:independent_contrasts",
             "pk_pic = phykit.phykit:independent_contrasts",
             "pk_phylo_contrasts = phykit.phykit:independent_contrasts",

phykit-2.1.46/phykit/version.py

@@ -1 +0,0 @@
-__version__ = "2.1.46"