phykit 2.1.63__tar.gz → 2.1.66__tar.gz

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

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: phykit
-Version: 2.1.63
+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.63 → phykit-2.1.66}/phykit/cli_registry.py

@@ -21,6 +21,8 @@ ALIAS_TO_HANDLER: Dict[str, str] = {
     "recode": "alignment_recoding",
     "outlier_taxa": "alignment_outlier_taxa",
     "aot": "alignment_outlier_taxa",
+    "dstat": "dstatistic",
+    "abba_baba": "dstatistic",
     "cs": "column_score",
     "comp_bias_per_site": "compositional_bias_per_site",
     "cbps": "compositional_bias_per_site",

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

@@ -119,6 +119,9 @@ class Phykit:
                     - recode alignments using reduced character schemes
                 alignment_subsample (alias: aln_subsample; subsample)
                     - randomly subsample genes, partitions, or sites
+                dstatistic (alias: dstat; abba_baba)
+                    - Patterson's D-statistic (ABBA-BABA test) for
+                      detecting introgression/gene flow
                 alignment_outlier_taxa (alias: outlier_taxa; aot)
                     - identify potential outlier taxa and why they were flagged
                 column_score (alias: cs)
@@ -1945,6 +1948,97 @@ class Phykit:
         _add_json_argument(parser)
         _run_service(parser, argv, AlignmentSubsample)
 
+    @staticmethod
+    def dstatistic(argv):
+        parser = _new_parser(
+            description=textwrap.dedent(
+                f"""\
+                {help_header}
+
+                Compute Patterson's D-statistic (ABBA-BABA test) for
+                detecting introgression or gene flow.
+
+                Two input modes:
+                1) Site patterns from an alignment (-a)
+                2) Quartet topologies from gene trees (-g)
+
+                Species topology: (((P1, P2), P3), Outgroup).
+                Under ILS alone, ABBA and BABA patterns (or
+                discordant topologies) are equally frequent. A
+                significant excess indicates introgression.
+
+                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
+                Command line interfaces:
+                  pk_dstatistic, pk_dstat, pk_abba_baba
+
+                Usage:
+                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)
+
+                --p2                        taxon name for P2
+                                            (sister to P1; potential
+                                            recipient of gene flow)
+
+                --p3                        taxon name for P3
+                                            (donor lineage)
+
+                --outgroup                  outgroup taxon name
+
+                --block-size                block size for jackknife
+                                            estimation of standard
+                                            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=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)
+
     ## Tree functions
     @staticmethod
     def parsimony_score(argv):
@@ -5486,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
                 """
@@ -5508,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)
@@ -7881,6 +7984,10 @@ def alignment_subsample(argv=None):
     Phykit.alignment_subsample(sys.argv[1:])
 
 
+def dstatistic(argv=None):
+    Phykit.dstatistic(sys.argv[1:])
+
+
 # Tree-based functions
 def parsimony_score(argv=None):
     Phykit.parsimony_score(sys.argv[1:])

{phykit-2.1.63 → phykit-2.1.66}/phykit/service_factories.py

@@ -29,6 +29,7 @@ CompositionalBiasPerSite = _LazyServiceFactory("phykit.services.alignment.compos
 CompositionPerTaxon = _LazyServiceFactory("phykit.services.alignment.composition_per_taxon", "CompositionPerTaxon")
 CreateConcatenationMatrix = _LazyServiceFactory("phykit.services.alignment.create_concatenation_matrix", "CreateConcatenationMatrix")
 DNAThreader = _LazyServiceFactory("phykit.services.alignment.dna_threader", "DNAThreader")
+Dstatistic = _LazyServiceFactory("phykit.services.alignment.dstatistic", "Dstatistic")
 EvolutionaryRatePerSite = _LazyServiceFactory("phykit.services.alignment.evolutionary_rate_per_site", "EvolutionaryRatePerSite")
 Faidx = _LazyServiceFactory("phykit.services.alignment.faidx", "Faidx")
 GCContent = _LazyServiceFactory("phykit.services.alignment.gc_content", "GCContent")

{phykit-2.1.63 → phykit-2.1.66}/phykit/services/alignment/__init__.py

@@ -12,6 +12,7 @@ _EXPORTS = {
     "CompositionPerTaxon": "composition_per_taxon",
     "CreateConcatenationMatrix": "create_concatenation_matrix",
     "DNAThreader": "dna_threader",
+    "Dstatistic": "dstatistic",
     "EvolutionaryRatePerSite": "evolutionary_rate_per_site",
     "Faidx": "faidx",
     "GCContent": "gc_content",

phykit-2.1.66/phykit/services/alignment/dstatistic.py

@@ -0,0 +1,420 @@
+"""Patterson's D-statistic (ABBA-BABA test) for detecting introgression.
+
+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 Phylo, SeqIO
+
+from .base import Alignment
+from ...helpers.json_output import print_json
+from ...errors import PhykitUserError
+
+
+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=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"):
+            sequences[record.id] = str(record.seq).upper()
+
+        # Validate taxa are present
+        required = {"p1": self.p1, "p2": self.p2, "p3": self.p3, "outgroup": self.outgroup}
+        for label, taxon in required.items():
+            if taxon not in sequences:
+                raise PhykitUserError(
+                    [f"Taxon '{taxon}' ({label}) not found in alignment. "
+                     f"Available taxa: {', '.join(sorted(sequences.keys()))}"],
+                    code=2,
+                )
+
+        seq_p1 = sequences[self.p1]
+        seq_p2 = sequences[self.p2]
+        seq_p3 = sequences[self.p3]
+        seq_outgroup = sequences[self.outgroup]
+
+        # Validate equal lengths
+        lengths = {len(seq_p1), len(seq_p2), len(seq_p3), len(seq_outgroup)}
+        if len(lengths) != 1:
+            raise PhykitUserError(
+                ["Sequences have different lengths. All sequences must be aligned."],
+                code=2,
+            )
+
+        aln_length = len(seq_p1)
+        skip_chars = {"-", "N", "?", "X", "n", "x"}
+
+        # Count site patterns
+        abba_count = 0
+        baba_count = 0
+
+        for site in range(aln_length):
+            p1 = seq_p1[site]
+            p2 = seq_p2[site]
+            p3 = seq_p3[site]
+            o = seq_outgroup[site]
+
+            # Skip sites with gaps or ambiguous characters
+            if any(c in skip_chars for c in [p1, p2, p3, o]):
+                continue
+
+            # Skip sites that are not biallelic
+            alleles = {p1, p2, p3, o}
+            if len(alleles) != 2:
+                continue
+
+            # ABBA: P1=ancestral, P2=derived, P3=derived, O=ancestral
+            if p1 == o and p2 != o and p3 != o and p2 == p3:
+                abba_count += 1
+            # BABA: P1=derived, P2=ancestral, P3=derived, O=ancestral
+            elif p2 == o and p1 != o and p3 != o and p1 == p3:
+                baba_count += 1
+
+        informative_sites = abba_count + baba_count
+
+        # Compute D-statistic
+        if informative_sites == 0:
+            d_stat = 0.0
+        else:
+            d_stat = (abba_count - baba_count) / informative_sites
+
+        # Block jackknife for significance
+        n_blocks = aln_length // self.block_size
+        se = None
+        z_score = None
+        p_value = None
+
+        if n_blocks >= 2:
+            block_abba = np.zeros(n_blocks)
+            block_baba = np.zeros(n_blocks)
+
+            for site in range(aln_length):
+                block_idx = site // self.block_size
+                if block_idx >= n_blocks:
+                    break
+
+                p1 = seq_p1[site]
+                p2 = seq_p2[site]
+                p3 = seq_p3[site]
+                o = seq_outgroup[site]
+
+                if any(c in skip_chars for c in [p1, p2, p3, o]):
+                    continue
+                alleles = {p1, p2, p3, o}
+                if len(alleles) != 2:
+                    continue
+
+                if p1 == o and p2 != o and p3 != o and p2 == p3:
+                    block_abba[block_idx] += 1
+                elif p2 == o and p1 != o and p3 != o and p1 == p3:
+                    block_baba[block_idx] += 1
+
+            total_abba = np.sum(block_abba)
+            total_baba = np.sum(block_baba)
+
+            jackknife_d = np.zeros(n_blocks)
+            for i in range(n_blocks):
+                loo_abba = total_abba - block_abba[i]
+                loo_baba = total_baba - block_baba[i]
+                denom = loo_abba + loo_baba
+                if denom > 0:
+                    jackknife_d[i] = (loo_abba - loo_baba) / denom
+                else:
+                    jackknife_d[i] = 0.0
+
+            mean_d = np.mean(jackknife_d)
+            se = float(np.sqrt((n_blocks - 1) / n_blocks * np.sum((jackknife_d - mean_d) ** 2)))
+
+            if se > 0:
+                z_score = d_stat / se
+                from scipy.stats import norm
+                p_value = float(2.0 * norm.sf(abs(z_score)))
+            else:
+                z_score = float('inf') if d_stat != 0 else 0.0
+                p_value = 0.0 if d_stat != 0 else 1.0
+
+        # Output
+        if self.json_output:
+            payload = {
+                "p1": self.p1,
+                "p2": self.p2,
+                "p3": self.p3,
+                "outgroup": self.outgroup,
+                "alignment_length": aln_length,
+                "informative_sites": informative_sites,
+                "abba_count": abba_count,
+                "baba_count": baba_count,
+                "d_statistic": round(d_stat, 4),
+                "block_size": self.block_size,
+                "n_blocks": n_blocks if n_blocks >= 2 else n_blocks,
+                "standard_error": round(se, 4) if se is not None else None,
+                "z_score": round(z_score, 2) if z_score is not None and z_score != float('inf') else z_score,
+                "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 (ABBA-BABA Test)")
+            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"Alignment length: {aln_length}")
+            print(f"Informative sites: {informative_sites}")
+            print(f"ABBA sites: {abba_count}")
+            print(f"BABA sites: {baba_count}")
+            print(f"D-statistic: {d_stat:.4f}")
+
+            if se is not None:
+                print(f"Block jackknife (block size: {self.block_size}):")
+                print(f"  Standard error: {se:.4f}")
+                if z_score == float('inf'):
+                    print("  Z-score: inf")
+                else:
+                    print(f"  Z-score: {z_score:.2f}")
+                print(f"  p-value: {p_value:.6f}")
+                print()
+                print(f"Interpretation: {self._interpret(d_stat, p_value)}")
+            else:
+                print()
+                print("Not enough blocks for jackknife significance test.")
+        except BrokenPipeError:
+            pass
+
+    def _interpret(self, d_stat: float, p_value: float, alpha: float = 0.05) -> str:
+        if p_value < alpha:
+            if d_stat > 0:
+                return (
+                    f"Significant excess of ABBA patterns (p < {alpha}) "
+                    f"suggests introgression between P2 ({self.p2}) and "
+                    f"P3 ({self.p3}). Note: D cannot determine the "
+                    f"direction of gene flow."
+                )
+            else:
+                return (
+                    f"Significant excess of BABA patterns (p < {alpha}) "
+                    f"suggests introgression between P1 ({self.p1}) and "
+                    f"P3 ({self.p3}). Note: D cannot determine the "
+                    f"direction of gene flow."
+                )
+        return "No significant evidence of introgression (consistent with ILS)."

{phykit-2.1.63 → 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.63 → phykit-2.1.66}/phykit.egg-info/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: phykit
-Version: 2.1.63
+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.63 → phykit-2.1.66}/phykit.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ phykit/services/alignment/composition_per_taxon.py
 phykit/services/alignment/compositional_bias_per_site.py
 phykit/services/alignment/create_concatenation_matrix.py
 phykit/services/alignment/dna_threader.py
+phykit/services/alignment/dstatistic.py
 phykit/services/alignment/evolutionary_rate_per_site.py
 phykit/services/alignment/faidx.py
 phykit/services/alignment/gc_content.py

{phykit-2.1.63 → phykit-2.1.66}/phykit.egg-info/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 phykit = phykit.phykit:main
+pk_abba_baba = phykit.phykit:dstatistic
 pk_al = phykit.phykit:alignment_length
 pk_alignment_entropy = phykit.phykit:alignment_entropy
 pk_alignment_length = phykit.phykit:alignment_length
@@ -63,6 +64,8 @@ pk_dimreduce = phykit.phykit:phylogenetic_ordination
 pk_disc_asym = phykit.phykit:discordance_asymmetry
 pk_discordance_asymmetry = phykit.phykit:discordance_asymmetry
 pk_dmap = phykit.phykit:density_map
+pk_dstat = phykit.phykit:dstatistic
+pk_dstatistic = phykit.phykit:dstatistic
 pk_dvmc = phykit.phykit:dvmc
 pk_entropy = phykit.phykit:alignment_entropy
 pk_erps = phykit.phykit:evolutionary_rate_per_site

{phykit-2.1.63 → 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": [
@@ -106,6 +107,9 @@ setup(
             "pk_alignment_subsample = phykit.phykit:alignment_subsample",
             "pk_aln_subsample = phykit.phykit:alignment_subsample",
             "pk_subsample = phykit.phykit:alignment_subsample",
+            "pk_dstatistic = phykit.phykit:dstatistic",
+            "pk_dstat = phykit.phykit:dstatistic",
+            "pk_abba_baba = phykit.phykit:dstatistic",
             "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",

phykit-2.1.63/phykit/version.py

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