phykit 2.1.23__tar.gz → 2.1.26__tar.gz

{phykit-2.1.23 → phykit-2.1.26}/PKG-INFO

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

{phykit-2.1.23 → phykit-2.1.26}/phykit/cli_registry.py

@@ -109,6 +109,13 @@ ALIAS_TO_HANDLER: Dict[str, str] = {
     "ou_shifts": "ou_shift_detection",
     "l1ou": "ou_shift_detection",
     "detect_shifts": "ou_shift_detection",
+    "quartet_net": "quartet_network",
+    "qnet": "quartet_network",
+    "nanuq": "quartet_network",
+    "netsig": "network_signal",
+    "net_signal": "network_signal",
+    "rrt": "relative_rate_test",
+    "tajima_rrt": "relative_rate_test",
     "polyt_test": "polytomy_test",
     "ptt": "polytomy_test",
     "polyt": "polytomy_test",

{phykit-2.1.23 → phykit-2.1.26}/phykit/phykit.py

@@ -232,6 +232,11 @@ class Phykit:
                 ou_shift_detection (alias: ou_shifts; l1ou; detect_shifts)
                     - automatic OU shift detection using LASSO
                       (Khabbazian et al. 2016)
+                quartet_network (alias: quartet_net; qnet; nanuq)
+                    - quartet-based network inference (NANUQ-style)
+                      distinguishing ILS from hybridization
+                network_signal (alias: netsig; net_signal)
+                    - phylogenetic signal on a network
                 polytomy_test (alias: polyt_test; polyt; ptt)
                     - conducts a polytomy test using gene
                       support frequencies
@@ -239,6 +244,9 @@ class Phykit:
                     - prints ascii tree
                 prune_tree (alias: prune)
                     - prune taxa from a phylogeny
+                relative_rate_test (alias: rrt; tajima_rrt)
+                    - Tajima's relative rate test for equal evolutionary
+                      rates between two ingroup lineages
                 rename_tree_tips (alias: rename_tree; rename_tips)
                     - renames tips in a phylogeny according to a file with
                       the desired new tip names
@@ -3636,6 +3644,196 @@ class Phykit:
         _add_json_argument(parser)
         _run_service(parser, argv, ConsensusNetwork)
 
+    @staticmethod
+    def quartet_network(argv):
+        parser = _new_parser(
+            description=textwrap.dedent(
+                f"""\
+                {help_header}
+
+                Quartet-based network inference (NANUQ-style).
+
+                Computes quartet concordance factors from gene trees,
+                classifies each quartet as tree-like, hybrid, or
+                unresolved using two chi-squared tests (matching the
+                NANUQ algorithm from MSCquartets), and optionally
+                visualizes the result as a species tree with
+                reticulation edges overlaid.
+
+                Star test: Pearson chi-squared against uniform (1/3
+                each). If p > beta, the quartet is unresolved.
+                Tree test (T3): G-test under the MSC tree model.
+                If p > alpha, the quartet is tree-like.
+                Otherwise the quartet shows hybrid signal.
+
+                Input can be either:
+                1) a file with one Newick tree per line, or
+                2) a file with one tree-file path per line.
+
+                Aliases:
+                  quartet_network, quartet_net, qnet, nanuq
+                Command line interfaces:
+                  pk_quartet_network, pk_quartet_net, pk_qnet,
+                  pk_nanuq
+
+                Usage:
+                phykit quartet_network -t/--trees <trees>
+                    [--alpha 0.05] [--beta 0.95]
+                    [--missing-taxa error|shared]
+                    [--plot-output <file>] [--json]
+
+                Options
+                =====================================================
+                -t/--trees                 file containing trees or
+                                           tree paths
+
+                --alpha                    significance level for the
+                                           T3 tree model test
+                                           (Default: 0.05)
+
+                --beta                     threshold for the star tree
+                                           test; quartets with
+                                           p_star > beta are called
+                                           unresolved
+                                           (Default: 0.95)
+
+                --missing-taxa             how to handle mismatched
+                                           taxa across trees:
+                                           error or shared
+                                           (Default: error)
+
+                --plot-output              output filename for the
+                                           quartet network plot
+                                           (optional)
+
+                --json                     optional argument to output
+                                           results as JSON
+                """
+            ),
+        )
+        parser.add_argument("-t", "--trees", type=str, required=True, help=SUPPRESS)
+        parser.add_argument(
+            "--alpha",
+            type=float,
+            default=0.05,
+            required=False,
+            help=SUPPRESS,
+        )
+        parser.add_argument(
+            "--beta",
+            type=float,
+            default=0.95,
+            required=False,
+            help=SUPPRESS,
+        )
+        parser.add_argument(
+            "--missing-taxa",
+            type=str,
+            choices=["error", "shared"],
+            default="error",
+            required=False,
+            help=SUPPRESS,
+        )
+        parser.add_argument(
+            "--plot-output",
+            type=str,
+            default=None,
+            required=False,
+            help=SUPPRESS,
+        )
+        _add_json_argument(parser)
+        _run_service(parser, argv, QuartetNetwork)
+
+    @staticmethod
+    def network_signal(argv):
+        parser = _new_parser(
+            description=textwrap.dedent(
+                f"""\
+                {help_header}
+
+                Phylogenetic signal on a network.
+
+                Measures phylogenetic signal (Bloomberg's K and/or
+                Pagel's lambda) on a phylogenetic network by
+                incorporating hybrid edges inferred from quartet
+                concordance factors.
+
+                Hybrid edges can be specified directly (--hybrid)
+                or loaded from a quartet network JSON file
+                (--quartet-json).
+
+                Aliases:
+                  network_signal, netsig, net_signal
+                Command line interfaces:
+                  pk_network_signal, pk_netsig, pk_net_signal
+
+                Usage:
+                phykit network_signal -t <tree> -d <trait_data>
+                    (--hybrid <P H1 H2 gamma> | --quartet-json <file>)
+                    [--method both|blombergs_k|lambda]
+                    [--permutations 1000] [-v/--verbose] [--json]
+
+                Options
+                =====================================================
+                -t/--tree                   a phylogeny file
+                                            (required)
+
+                -d/--trait-data             tab-delimited trait data
+                                            file (required)
+
+                --hybrid                    hybrid specification:
+                                            parent hybrid child1
+                                            child2 gamma (nargs +)
+
+                --quartet-json              path to quartet network
+                                            JSON output file
+
+                --method                    which signal measure to
+                                            compute: both, blombergs_k,
+                                            or lambda
+                                            (Default: both)
+
+                --permutations              number of permutations
+                                            for significance testing
+                                            (Default: 1000)
+
+                -v/--verbose                print detailed output
+
+                --json                      optional argument to output
+                                            results as JSON
+                """
+            ),
+        )
+        parser.add_argument("-t", "--tree", type=str, required=True, help=SUPPRESS)
+        parser.add_argument("-d", "--trait-data", type=str, required=True, help=SUPPRESS)
+        hybrid_group = parser.add_mutually_exclusive_group(required=True)
+        hybrid_group.add_argument(
+            "--hybrid", nargs="+", type=str, help=SUPPRESS
+        )
+        hybrid_group.add_argument(
+            "--quartet-json", type=str, help=SUPPRESS
+        )
+        parser.add_argument(
+            "--method",
+            type=str,
+            choices=["both", "blombergs_k", "lambda"],
+            default="both",
+            required=False,
+            help=SUPPRESS,
+        )
+        parser.add_argument(
+            "--permutations",
+            type=int,
+            default=1000,
+            required=False,
+            help=SUPPRESS,
+        )
+        parser.add_argument(
+            "-v", "--verbose", action="store_true", required=False, help=SUPPRESS
+        )
+        _add_json_argument(parser)
+        _run_service(parser, argv, NetworkSignal)
+
     @staticmethod
     def prune_tree(argv):
         parser = _new_parser(
@@ -3693,6 +3891,72 @@ class Phykit:
         _add_json_argument(parser)
         _run_service(parser, argv, PruneTree)
 
+    @staticmethod
+    def relative_rate_test(argv):
+        parser = _new_parser(
+            description=textwrap.dedent(
+                f"""\
+                {help_header}
+
+                Tajima's relative rate test.
+
+                Tests whether two ingroup lineages evolve at
+                equal rates relative to an outgroup.  The tree
+                must be rooted with a single outgroup taxon.
+                All pairwise ingroup comparisons are performed
+                with Bonferroni and BH-FDR correction.
+
+                Provide either a single alignment (-a) or a
+                file listing multiple alignment paths (-l) for
+                batch (multi-gene) analysis.
+
+                Aliases:
+                  relative_rate_test, rrt, tajima_rrt
+                Command line interfaces:
+                  pk_relative_rate_test, pk_rrt, pk_tajima_rrt
+
+                Usage:
+                phykit relative_rate_test (-a <alignment> | -l <alignment_list>) -t <tree> [-v/--verbose] [--json]
+
+                Options
+                =====================================================
+                -a/--alignment              a single alignment file
+
+                -l/--alignment-list         a file listing alignment
+                                            paths (one per line)
+
+                -t/--tree                   a rooted tree file
+                                            (required)
+
+                -v/--verbose                print detailed output
+
+                --plot-output               save pairwise p-value
+                                            heatmap to this path
+
+                --json                      optional argument to output
+                                            results as JSON
+                """
+            ),
+        )
+        aln_group = parser.add_mutually_exclusive_group()
+        aln_group.add_argument(
+            "-a", "--alignment", type=str, required=False, help=SUPPRESS, metavar=""
+        )
+        aln_group.add_argument(
+            "-l", "--alignment-list", dest="alignment_list", type=str, required=False, help=SUPPRESS, metavar=""
+        )
+        parser.add_argument(
+            "-t", "--tree", type=str, required=True, help=SUPPRESS, metavar=""
+        )
+        parser.add_argument(
+            "-v", "--verbose", action="store_true", required=False, help=SUPPRESS
+        )
+        parser.add_argument(
+            "--plot-output", type=str, required=False, help=SUPPRESS, metavar=""
+        )
+        _add_json_argument(parser)
+        _run_service(parser, argv, RelativeRateTest)
+
     @staticmethod
     def rename_tree_tips(argv):
         parser = _new_parser(
@@ -4658,6 +4922,14 @@ def consensus_network(argv=None):
     Phykit.consensus_network(sys.argv[1:])
 
 
+def quartet_network(argv=None):
+    Phykit.quartet_network(sys.argv[1:])
+
+
+def network_signal(argv=None):
+    Phykit.network_signal(sys.argv[1:])
+
+
 def consensus_tree(argv=None):
     Phykit.consensus_tree(sys.argv[1:])
 
@@ -4666,6 +4938,10 @@ def prune_tree(argv=None):
     Phykit.prune_tree(sys.argv[1:])
 
 
+def relative_rate_test(argv=None):
+    Phykit.relative_rate_test(sys.argv[1:])
+
+
 def rename_tree_tips(argv=None):
     Phykit.rename_tree_tips(sys.argv[1:])
 

{phykit-2.1.23 → phykit-2.1.26}/phykit/service_factories.py

@@ -75,6 +75,9 @@ RateHeterogeneity = _LazyServiceFactory("phykit.services.tree.rate_heterogeneity
 FitContinuous = _LazyServiceFactory("phykit.services.tree.fit_continuous", "FitContinuous")
 OUwie = _LazyServiceFactory("phykit.services.tree.ouwie", "OUwie")
 OUShiftDetection = _LazyServiceFactory("phykit.services.tree.ou_shift_detection", "OUShiftDetection")
+QuartetNetwork = _LazyServiceFactory("phykit.services.tree.quartet_network", "QuartetNetwork")
+NetworkSignal = _LazyServiceFactory("phykit.services.tree.network_signal", "NetworkSignal")
+RelativeRateTest = _LazyServiceFactory("phykit.services.tree.relative_rate_test", "RelativeRateTest")
 PolytomyTest = _LazyServiceFactory("phykit.services.tree.polytomy_test", "PolytomyTest")
 PrintTree = _LazyServiceFactory("phykit.services.tree.print_tree", "PrintTree")
 PruneTree = _LazyServiceFactory("phykit.services.tree.prune_tree", "PruneTree")

{phykit-2.1.23 → phykit-2.1.26}/phykit/services/tree/__init__.py

@@ -18,6 +18,9 @@ _EXPORTS = {
     "MonophylyCheck": "monophyly_check",
     "NearestNeighborInterchange": "nearest_neighbor_interchange",
     "PatristicDistances": "patristic_distances",
+    "QuartetNetwork": "quartet_network",
+    "NetworkSignal": "network_signal",
+    "RelativeRateTest": "relative_rate_test",
     "PolytomyTest": "polytomy_test",
     "PrintTree": "print_tree",
     "PruneTree": "prune_tree",