phykit 2.1.64__tar.gz → 2.1.66__tar.gz

{phykit-2.1.64 → phykit-2.1.66}/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: phykit
-Version: 2.1.64
+Version: 2.1.66
 Home-page: https://github.com/jlsteenwyk/phykit
 Author: Jacob L. Steenwyk
 Author-email: jlsteenwyk@gmail.com
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.11
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: biopython>=1.82

{phykit-2.1.64 → phykit-2.1.66}/phykit/phykit.py

@@ -1956,21 +1956,26 @@ class Phykit:
                 {help_header}
 
                 Compute Patterson's D-statistic (ABBA-BABA test) for
-                detecting introgression or gene flow from a four-taxon
-                alignment.
+                detecting introgression or gene flow.
 
-                The assumed topology is (((P1, P2), P3), Outgroup).
-                Under incomplete lineage sorting (ILS) alone, ABBA and
-                BABA site patterns should be equally frequent. A
-                significant excess of either pattern indicates gene
-                flow.
+                Two input modes:
+                1) Site patterns from an alignment (-a)
+                2) Quartet topologies from gene trees (-g)
 
-                D > 0 suggests gene flow between P2 and P3.
-                D < 0 suggests gene flow between P1 and P3.
-                D = 0 is consistent with ILS alone.
+                Species topology: (((P1, P2), P3), Outgroup).
+                Under ILS alone, ABBA and BABA patterns (or
+                discordant topologies) are equally frequent. A
+                significant excess indicates introgression.
 
-                Significance is assessed via block jackknife (Green
-                et al. 2010; Patterson et al. 2012).
+                D > 0: introgression between P2 and P3.
+                D < 0: introgression between P1 and P3.
+                D = 0: consistent with ILS alone.
+                Note: D identifies which lineages exchanged genes
+                but cannot determine direction of flow.
+
+                Gene trees can have any number of taxa; only the
+                quartet induced by the four specified taxa is
+                evaluated from each tree.
 
                 Aliases:
                   dstatistic, dstat, abba_baba
@@ -1978,13 +1983,22 @@ class Phykit:
                   pk_dstatistic, pk_dstat, pk_abba_baba
 
                 Usage:
-                phykit dstatistic -a <alignment> --p1 <taxon> --p2 <taxon>
-                    --p3 <taxon> --outgroup <taxon>
+                phykit dstatistic -a <alignment> --p1 <taxon>
+                    --p2 <taxon> --p3 <taxon> --outgroup <taxon>
                     [--block-size 100] [--json]
+                phykit dstatistic -g <gene_trees> --p1 <taxon>
+                    --p2 <taxon> --p3 <taxon> --outgroup <taxon>
+                    [--json]
 
                 Options
                 =====================================================
                 -a/--alignment              FASTA alignment file
+                                            (site-pattern mode)
+
+                -g/--gene-trees             gene trees file, one
+                                            Newick per line (gene-
+                                            tree mode; trees can
+                                            have any number of taxa)
 
                 --p1                        taxon name for P1
                                             (sister to P2)
@@ -2000,18 +2014,28 @@ class Phykit:
 
                 --block-size                block size for jackknife
                                             estimation of standard
-                                            error (default: 100)
+                                            error (default: 100;
+                                            alignment mode only)
+
+                --support                   minimum branch support
+                                            threshold for gene trees;
+                                            branches below this value
+                                            are collapsed (treated as
+                                            unresolved). Gene-tree
+                                            mode only.
 
                 --json                      output results as JSON
                 """
             ),
         )
-        parser.add_argument("-a", "--alignment", type=str, required=True, help=SUPPRESS, metavar="")
+        parser.add_argument("-a", "--alignment", type=str, required=False, default=None, help=SUPPRESS, metavar="")
+        parser.add_argument("-g", "--gene-trees", type=str, required=False, default=None, help=SUPPRESS, metavar="")
         parser.add_argument("--p1", type=str, required=True, help=SUPPRESS, metavar="")
         parser.add_argument("--p2", type=str, required=True, help=SUPPRESS, metavar="")
         parser.add_argument("--p3", type=str, required=True, help=SUPPRESS, metavar="")
         parser.add_argument("--outgroup", type=str, required=True, help=SUPPRESS, metavar="")
         parser.add_argument("--block-size", type=int, default=100, help=SUPPRESS, metavar="")
+        parser.add_argument("--support", type=float, default=None, help=SUPPRESS, metavar="")
         _add_json_argument(parser)
         _run_service(parser, argv, Dstatistic)
 
@@ -5556,6 +5580,11 @@ class Phykit:
                 --csv                       output per-branch concordance
                                             values as a CSV file
 
+                --pie-size                  scale factor for pie chart
+                                            size (default: 1.0; use
+                                            2.0 for double, 0.5 for
+                                            half, etc.)
+
                 --json                      optional argument to output
                                             per-node concordance as JSON
                 """
@@ -5578,6 +5607,10 @@ class Phykit:
             "--csv", type=str, required=False, default=None,
             help=SUPPRESS, metavar=""
         )
+        parser.add_argument(
+            "--pie-size", type=float, required=False, default=1.0,
+            help=SUPPRESS, metavar=""
+        )
         add_plot_arguments(parser)
         _add_json_argument(parser)
         _run_service(parser, argv, QuartetPie)

{phykit-2.1.64 → phykit-2.1.66}/phykit/services/alignment/dstatistic.py

@@ -1,9 +1,15 @@
-"""Patterson's D-statistic (ABBA-BABA test) for detecting introgression."""
+"""Patterson's D-statistic (ABBA-BABA test) for detecting introgression.
 
-from typing import Dict
+Supports two modes:
+1) Site patterns from a FASTA alignment (-a)
+2) Quartet topologies from gene trees (-g)
+"""
+
+from io import StringIO
+from typing import Dict, List, Optional, Tuple
 
 import numpy as np
-from Bio import SeqIO
+from Bio import Phylo, SeqIO
 
 from .base import Alignment
 from ...helpers.json_output import print_json
@@ -14,25 +20,215 @@ class Dstatistic(Alignment):
     def __init__(self, args) -> None:
         parsed = self.process_args(args)
         super().__init__(alignment_file_path=parsed["alignment_path"])
+        self.gene_trees_path = parsed["gene_trees_path"]
         self.p1 = parsed["p1"]
         self.p2 = parsed["p2"]
         self.p3 = parsed["p3"]
         self.outgroup = parsed["outgroup"]
         self.block_size = parsed["block_size"]
+        self.support_threshold = parsed["support_threshold"]
         self.json_output = parsed["json_output"]
 
     def process_args(self, args) -> Dict[str, object]:
+        aln = getattr(args, "alignment", None)
+        gt = getattr(args, "gene_trees", None)
+        if aln is None and gt is None:
+            raise PhykitUserError(
+                ["Either -a/--alignment or -g/--gene-trees is required."],
+                code=2,
+            )
+        if aln is not None and gt is not None:
+            raise PhykitUserError(
+                ["-a/--alignment and -g/--gene-trees are mutually exclusive."],
+                code=2,
+            )
         return dict(
-            alignment_path=args.alignment,
+            alignment_path=aln,
+            gene_trees_path=gt,
             p1=args.p1,
             p2=args.p2,
             p3=args.p3,
             outgroup=args.outgroup,
             block_size=getattr(args, "block_size", 100),
+            support_threshold=getattr(args, "support", None),
             json_output=getattr(args, "json", False),
         )
 
     def run(self):
+        if self.gene_trees_path:
+            self._run_gene_tree_mode()
+        else:
+            self._run_alignment_mode()
+
+    # ------------------------------------------------------------------
+    # Gene tree mode
+    # ------------------------------------------------------------------
+
+    def _run_gene_tree_mode(self):
+        """Count quartet topologies from gene trees."""
+        gene_trees = self._parse_gene_trees(self.gene_trees_path)
+        quartet = (self.p1, self.p2, self.p3, self.outgroup)
+
+        # For each gene tree, determine the quartet topology
+        # Species tree: (((P1,P2),P3),O)
+        # Concordant: P1+P2 together → ((P1,P2),(P3,O))
+        # ABBA: P2+P3 together → ((P2,P3),(P1,O))
+        # BABA: P1+P3 together → ((P1,P3),(P2,O))
+        concordant = 0
+        abba_count = 0
+        baba_count = 0
+        unresolved = 0
+
+        for gt in gene_trees:
+            topo = self._get_quartet_topology(gt, quartet)
+            if topo == "concordant":
+                concordant += 1
+            elif topo == "abba":
+                abba_count += 1
+            elif topo == "baba":
+                baba_count += 1
+            else:
+                unresolved += 1
+
+        n_informative = abba_count + baba_count
+        n_total = len(gene_trees)
+
+        # D-statistic
+        if n_informative == 0:
+            d_stat = 0.0
+        else:
+            d_stat = (abba_count - baba_count) / n_informative
+
+        # Chi-squared test: are ABBA and BABA equally frequent?
+        from scipy.stats import chi2
+
+        p_value = None
+        chi2_stat = None
+        if n_informative > 0:
+            expected = n_informative / 2.0
+            chi2_stat = ((abba_count - expected) ** 2 + (baba_count - expected) ** 2) / expected
+            p_value = float(chi2.sf(chi2_stat, df=1))
+
+        # Output
+        if self.json_output:
+            payload = {
+                "mode": "gene_trees",
+                "p1": self.p1,
+                "p2": self.p2,
+                "p3": self.p3,
+                "outgroup": self.outgroup,
+                "n_gene_trees": n_total,
+                "concordant": concordant,
+                "abba_count": abba_count,
+                "baba_count": baba_count,
+                "unresolved": unresolved,
+                "d_statistic": round(d_stat, 4),
+                "support_threshold": self.support_threshold,
+                "chi2_statistic": round(chi2_stat, 4) if chi2_stat is not None else None,
+                "p_value": round(p_value, 6) if p_value is not None else None,
+            }
+            print_json(payload, sort_keys=False)
+            return
+
+        try:
+            print("Patterson's D-statistic (Gene Tree Mode)")
+            print("=========================================")
+            print(f"Topology: ((({self.p1}, {self.p2}), {self.p3}), {self.outgroup})")
+            print(f"P1: {self.p1}")
+            print(f"P2: {self.p2}")
+            print(f"P3: {self.p3}")
+            print(f"Outgroup: {self.outgroup}")
+            print()
+            print(f"Gene trees: {n_total}")
+            if self.support_threshold is not None:
+                print(f"Support threshold: {self.support_threshold}")
+            print(f"Concordant ((P1,P2),P3): {concordant}")
+            print(f"ABBA ((P2,P3),P1): {abba_count}")
+            print(f"BABA ((P1,P3),P2): {baba_count}")
+            print(f"Unresolved: {unresolved}")
+            print(f"D-statistic: {d_stat:.4f}")
+            if chi2_stat is not None:
+                print(f"Chi-squared: {chi2_stat:.4f}")
+                print(f"p-value: {p_value:.6f}")
+                print()
+                print(f"Interpretation: {self._interpret(d_stat, p_value)}")
+            else:
+                print()
+                print("No informative (discordant) gene trees found.")
+        except BrokenPipeError:
+            pass
+
+    def _parse_gene_trees(self, path: str) -> list:
+        """Parse gene trees from a file (one Newick per line)."""
+        try:
+            return list(Phylo.parse(path, "newick"))
+        except Exception:
+            raise PhykitUserError(
+                [f"Could not parse gene trees from {path}."],
+                code=2,
+            )
+
+    def _get_quartet_topology(self, tree, quartet) -> str:
+        """Determine quartet topology from a (possibly multi-taxon) gene tree.
+
+        If support_threshold is set, branches with support below the
+        threshold are excluded (treated as collapsed/unresolved).
+
+        Returns 'concordant', 'abba', 'baba', or 'unresolved'.
+        """
+        p1, p2, p3, outgroup = quartet
+
+        # Get all taxa in the tree
+        tree_taxa = {t.name for t in tree.get_terminals()}
+
+        # Check all four taxa are present
+        if not all(t in tree_taxa for t in quartet):
+            return "unresolved"
+
+        # Extract bipartitions from the gene tree
+        # Skip branches with support below threshold
+        all_taxa = frozenset(tree_taxa)
+        bipartitions = []
+        for clade in tree.get_nonterminals():
+            # Check support threshold
+            if self.support_threshold is not None:
+                support = clade.confidence
+                if support is not None and support < self.support_threshold:
+                    continue  # collapse this branch (skip its bipartition)
+
+            tips = frozenset(t.name for t in clade.get_terminals())
+            if len(tips) <= 1 or tips == all_taxa:
+                continue
+            complement = all_taxa - tips
+            if len(complement) <= 0:
+                continue
+            bipartitions.append((tips, complement))
+
+        # Check which quartet topology the bipartitions support
+        quartet_set = {p1, p2, p3, outgroup}
+        for side_a, side_b in bipartitions:
+            in_a = quartet_set & side_a
+            in_b = quartet_set & side_b
+            if len(in_a) == 2 and len(in_b) == 2:
+                pair = frozenset(in_a)
+                # Concordant: P1+P2 on one side
+                if pair == frozenset({p1, p2}) or pair == frozenset({p3, outgroup}):
+                    return "concordant"
+                # ABBA: P2+P3 on one side
+                if pair == frozenset({p2, p3}) or pair == frozenset({p1, outgroup}):
+                    return "abba"
+                # BABA: P1+P3 on one side
+                if pair == frozenset({p1, p3}) or pair == frozenset({p2, outgroup}):
+                    return "baba"
+
+        return "unresolved"
+
+    # ------------------------------------------------------------------
+    # Alignment mode
+    # ------------------------------------------------------------------
+
+    def _run_alignment_mode(self):
+        """Count ABBA/BABA site patterns from an alignment."""
         # Read alignment sequences
         sequences = {}
         for record in SeqIO.parse(self.alignment_file_path, "fasta"):

{phykit-2.1.64 → phykit-2.1.66}/phykit/services/tree/quartet_pie.py

@@ -48,6 +48,7 @@ class QuartetPie(Tree):
         self.annotate = parsed["annotate"]
         self.json_output = parsed["json_output"]
         self.csv_output = parsed["csv_output"]
+        self.pie_size = parsed["pie_size"]
         self.plot_config = parsed["plot_config"]
 
     def run(self) -> None:
@@ -104,6 +105,7 @@ class QuartetPie(Tree):
             annotate=getattr(args, "annotate", False),
             json_output=getattr(args, "json", False),
             csv_output=getattr(args, "csv", None),
+            pie_size=getattr(args, "pie_size", 1.0),
             plot_config=PlotConfig.from_args(args),
         )
 
@@ -253,7 +255,7 @@ class QuartetPie(Tree):
             # Circular mode: scale with n_tips but stay larger than rectangular
             # since radial spacing gives more room between nodes
             n_tips = len(tips)
-            pie_size = min(0.05, 0.6 / max(n_tips, 1))
+            pie_size = min(0.05, 0.6 / max(n_tips, 1)) * self.pie_size
 
             for clade in tree.find_clades(order="preorder"):
                 if clade.is_terminal() or clade == root:
@@ -400,7 +402,7 @@ class QuartetPie(Tree):
             # appear as perfect circles regardless of axis scaling, and are
             # drawn above the phylogeny branches.
             n_tips = len(tips)
-            pie_size = min(0.06, 0.8 / max(n_tips, 1))
+            pie_size = min(0.06, 0.8 / max(n_tips, 1)) * self.pie_size
 
             for clade in tree.find_clades(order="preorder"):
                 if clade.is_terminal() or clade == root:

phykit-2.1.66/phykit/version.py

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

{phykit-2.1.64 → phykit-2.1.66}/phykit.egg-info/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: phykit
-Version: 2.1.64
+Version: 2.1.66
 Home-page: https://github.com/jlsteenwyk/phykit
 Author: Jacob L. Steenwyk
 Author-email: jlsteenwyk@gmail.com
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.11
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: biopython>=1.82

{phykit-2.1.64 → phykit-2.1.66}/setup.py

@@ -12,6 +12,7 @@ CLASSIFIERS = [
     'Operating System :: OS Independent',
     'Intended Audience :: Science/Research',
     'Programming Language :: Python',
+    'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
     'Programming Language :: Python :: 3.13',
@@ -37,7 +38,7 @@ setup(
     author_email="jlsteenwyk@gmail.com",
     url="https://github.com/jlsteenwyk/phykit",
     packages=find_packages(),
-    python_requires=">=3.11",
+    python_requires=">=3.10",
     classifiers=CLASSIFIERS,
     entry_points={
         "console_scripts": [

phykit-2.1.64/phykit/version.py

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