phykit 2.1.0__py3-none-any.whl

phykit/services/tree/hidden_paralogy_check.py

@@ -0,0 +1,128 @@
+import sys
+from typing import Dict, List, Union
+from functools import lru_cache
+import multiprocessing as mp
+from functools import partial
+
+from Bio import Phylo
+
+from .base import Tree
+
+
+class HiddenParalogyCheck(Tree):
+    def __init__(self, args) -> None:
+        super().__init__(**self.process_args(args))
+
+    @staticmethod
+    def _process_clade_batch(clade_batch, tree_file_path, master_tree_tips):
+        """Process a batch of clades in parallel."""
+        batch_results = []
+
+        for clade in clade_batch:
+            # Read a fresh copy of the tree for each clade
+            tree = Phylo.read(tree_file_path, "newick")
+            clade_of_interest = set(clade).intersection(master_tree_tips)
+
+            if len(clade_of_interest) <= 1:
+                batch_results.append(["insufficient_taxon_representation"])
+                continue
+
+            diff_tips = master_tree_tips - clade_of_interest
+
+            # Root and find common ancestor
+            try:
+                tree.root_with_outgroup(list(diff_tips))
+                subtree = tree.common_ancestor(clade_of_interest)
+
+                # Get terminal names efficiently
+                common_ancestor_tips = set(tip.name for tip in subtree.get_terminals())
+
+                diff_tips_between_clade_and_curr_tree = \
+                    clade_of_interest.symmetric_difference(common_ancestor_tips)
+
+                batch_results.append([
+                    "monophyletic" if not diff_tips_between_clade_and_curr_tree else "not_monophyletic",
+                    list(diff_tips_between_clade_and_curr_tree),
+                ])
+            except (ValueError, AttributeError):
+                # Handle edge cases where rooting fails
+                batch_results.append(["processing_error"])
+
+        return batch_results
+
+    def run(self) -> None:
+        # Read the master tree once to get all tip names
+        master_tree = self.read_tree_file()
+        master_tree_tips = frozenset(self.get_tip_names_from_tree(master_tree))
+
+        # Read clades
+        clades = self.read_clades_file(self.clade)
+
+        # For small datasets, process sequentially
+        if len(clades) < 10:
+            res_arr = []
+            for clade in clades:
+                # Read a fresh tree for each clade instead of deep copying
+                tree = Phylo.read(self.tree_file_path, "newick")
+                clade_of_interest = set(clade).intersection(master_tree_tips)
+
+                if len(clade_of_interest) <= 1:
+                    res_arr.append(["insufficient_taxon_representation"])
+                    continue
+
+                diff_tips = master_tree_tips - clade_of_interest
+                tree.root_with_outgroup(list(diff_tips))
+
+                subtree = tree.common_ancestor(clade_of_interest)
+                common_ancestor_tips = set(self.get_tip_names_from_tree(subtree))
+
+                diff_tips_between_clade_and_curr_tree = \
+                    clade_of_interest.symmetric_difference(common_ancestor_tips)
+
+                res_arr.append([
+                    "monophyletic" if not diff_tips_between_clade_and_curr_tree else "not_monophyletic",
+                    list(diff_tips_between_clade_and_curr_tree),
+                ])
+        else:
+            # Use multiprocessing for larger datasets
+            num_workers = min(mp.cpu_count(), 8)
+            batch_size = max(1, len(clades) // num_workers)
+
+            # Create clade batches
+            clade_batches = [clades[i:i + batch_size]
+                           for i in range(0, len(clades), batch_size)]
+
+            # Process batches in parallel
+            process_func = partial(
+                self._process_clade_batch,
+                tree_file_path=self.tree_file_path,
+                master_tree_tips=master_tree_tips
+            )
+
+            with mp.Pool(processes=num_workers) as pool:
+                batch_results = pool.map(process_func, clade_batches)
+
+            # Flatten results
+            res_arr = []
+            for batch_result in batch_results:
+                res_arr.extend(batch_result)
+
+        self.print_results(res_arr)
+
+    def process_args(self, args) -> Dict[str, str]:
+        return dict(
+            tree_file_path=args.tree,
+            clade=args.clade,
+        )
+
+    def read_clades_file(self, clades: str) -> List[List[str]]:
+        try:
+            with open(clades, 'r') as file:
+                return [line.split() for line in file.readlines()]
+        except FileNotFoundError:
+            print("Clade file not found. Please check the path.")
+            sys.exit(2)
+
+    def print_results(self, res_arr: List[List[Union[List, str]]]) -> None:
+        for res in res_arr:
+            print(res[0])

phykit/services/tree/internal_branch_stats.py

@@ -0,0 +1,77 @@
+import sys
+from typing import (
+    Dict,
+    List,
+    Tuple,
+)
+
+from Bio.Phylo import Newick
+
+from .base import Tree
+
+from ...helpers.stats_summary import calculate_summary_statistics_from_arr, print_summary_statistics
+
+
+class InternalBranchStats(Tree):
+    def __init__(self, args) -> None:
+        super().__init__(**self.process_args(args))
+
+    def run(self):
+        tree = self.read_tree_file()
+        stats, lengths_and_names \
+            = self.calculate_internal_branch_stats(tree)
+
+        if self.verbose:
+            try:
+                for length, names in lengths_and_names:
+                    print(round(length, 4), ";".join(names))
+            except BrokenPipeError:
+                pass
+        else:
+            print_summary_statistics(stats)
+
+    def process_args(self, args) -> Dict[str, str]:
+        return dict(tree_file_path=args.tree, verbose=args.verbose)
+
+    def get_internal_branch_lengths(
+        self,
+        tree: Newick.Tree
+    ) -> Tuple[
+        List[float],
+        List[Tuple[float, List[str]]]
+    ]:
+        internal_branch_lengths = []
+        lengths_and_names = []
+
+        # Collect branch lengths and associated names in one pass
+        for internal_branch in tree.get_nonterminals():
+            if internal_branch.branch_length is not None:
+                internal_branch_lengths.append(internal_branch.branch_length)
+                term_names = [
+                    term.name for term in internal_branch.get_terminals()
+                ]
+                lengths_and_names.append(
+                    (
+                        internal_branch.branch_length, term_names
+                    )
+                )
+
+        return internal_branch_lengths, lengths_and_names
+
+    def calculate_internal_branch_stats(
+        self,
+        tree: Newick.Tree
+    ) -> Tuple[
+        Dict[str, float],
+        List[Tuple[float, List[str]]],
+    ]:
+        internal_branch_lengths, lengths_and_names = \
+            self.get_internal_branch_lengths(tree)
+
+        if not internal_branch_lengths:
+            print("Calculating internal branch statistics requires a phylogeny with branch lengths.")
+            sys.exit(2)
+
+        stats = calculate_summary_statistics_from_arr(internal_branch_lengths)
+
+        return stats, lengths_and_names

phykit/services/tree/internode_labeler.py

@@ -0,0 +1,33 @@
+from typing import Dict
+import copy
+
+from Bio.Phylo import Newick
+
+from .base import Tree
+
+
+class InternodeLabeler(Tree):
+    def __init__(self, args) -> None:
+        super().__init__(**self.process_args(args))
+
+    def run(self):
+        tree = self.read_tree_file()
+        # Make a deep copy to avoid modifying the cached tree
+        tree_copy = copy.deepcopy(tree)
+        self.add_labels_to_tree(tree_copy)
+        self.write_tree_file(tree_copy, self.output_file_path)
+
+    def process_args(self, args) -> Dict[str, str]:
+        output_file_path = args.output or f"{args.tree}.internode_labels.tre"
+
+        return dict(
+            tree_file_path=args.tree,
+            output_file_path=output_file_path,
+        )
+
+    def add_labels_to_tree(
+        self,
+        tree: Newick.Tree
+    ) -> None:
+        for label, node in enumerate(tree.get_nonterminals(), start=1):
+            node.confidence = label

phykit/services/tree/last_common_ancestor_subtree.py

@@ -0,0 +1,35 @@
+import sys
+import copy
+from typing import Dict
+
+from .base import Tree
+
+from ...helpers.files import read_single_column_file_to_list
+
+
+class LastCommonAncestorSubtree(Tree):
+    def __init__(self, args) -> None:
+        super().__init__(**self.process_args(args))
+
+    def run(self):
+        tree = self.read_tree_file()
+        # Make a deep copy to avoid issues with cached tree modifications
+        tree_copy = copy.deepcopy(tree)
+        try:
+            taxa = read_single_column_file_to_list(self.list_of_taxa)
+        except FileNotFoundError:
+            print("Taxa list file is not found. Please check pathing.")
+            sys.exit(2)
+        subtree = tree_copy.common_ancestor(taxa)
+
+        self.write_tree_file(subtree, self.output_file_path)
+
+    def process_args(self, args) -> Dict[str, str]:
+        tree_file_path = args.tree
+        output_file_path = args.output or f"{tree_file_path}.subtree.tre"
+
+        return dict(
+            tree_file_path=tree_file_path,
+            output_file_path=output_file_path,
+            list_of_taxa=args.list_of_taxa,
+        )

phykit/services/tree/lb_score.py

@@ -0,0 +1,196 @@
+import sys
+import itertools
+from typing import Dict, List, Tuple
+from concurrent.futures import ProcessPoolExecutor, as_completed
+import multiprocessing as mp
+import numpy as np
+import pickle
+from functools import lru_cache
+try:
+    from tqdm import tqdm
+    HAS_TQDM = True
+except ImportError:
+    HAS_TQDM = False
+
+from Bio.Phylo import Newick
+
+from .base import Tree
+
+from ...helpers.stats_summary import (
+    calculate_summary_statistics_from_arr,
+    print_summary_statistics,
+)
+
+
+class LBScore(Tree):
+    def __init__(self, args) -> None:
+        super().__init__(**self.process_args(args))
+
+    def run(self) -> None:
+        tree = self.read_tree_file()
+        tips, LBis = self.calculate_lb_score(tree)
+        if self.verbose:
+            try:
+                for tip, LBi in zip(tips, LBis):
+                    print(f"{tip}\t{round(LBi, 4)}")
+            except BrokenPipeError:
+                pass
+        else:
+            stats = calculate_summary_statistics_from_arr(LBis)
+            print_summary_statistics(stats)
+
+    def process_args(self, args) -> Dict[str, str]:
+        return dict(tree_file_path=args.tree, verbose=args.verbose)
+
+    @staticmethod
+    def _calculate_distances_batch(tree_pickle, tip_pairs):
+        """Calculate distances for a batch of tip pairs."""
+        tree = pickle.loads(tree_pickle)
+        return [tree.distance(tip1, tip2) for tip1, tip2 in tip_pairs]
+
+    def calculate_average_distance_between_tips(
+        self,
+        tips: List[str],
+        tree: Newick.Tree,
+    ) -> float:
+        num_tips = len(tips)
+        if num_tips < 2:
+            return 0
+
+        # Get all combinations
+        all_pairs = list(itertools.combinations(tips, 2))
+        num_combos = len(all_pairs)
+
+        # For small datasets, use sequential processing
+        if num_combos < 100:
+            total_dist = sum(
+                tree.distance(tip1, tip2)
+                for tip1, tip2 in all_pairs
+            )
+        else:
+            # Use multiprocessing for large datasets
+            tree_pickle = pickle.dumps(tree)
+            batch_size = max(50, num_combos // mp.cpu_count())
+
+            with ProcessPoolExecutor(max_workers=min(mp.cpu_count(), 8)) as executor:
+                futures = []
+                for i in range(0, num_combos, batch_size):
+                    batch = all_pairs[i:i + batch_size]
+                    futures.append(
+                        executor.submit(self._calculate_distances_batch, tree_pickle, batch)
+                    )
+
+                total_dist = 0
+                # Add progress bar if available and dataset is large
+                if HAS_TQDM and num_combos > 1000:
+                    futures_iter = tqdm(as_completed(futures), total=len(futures), desc="Computing distances")
+                else:
+                    futures_iter = as_completed(futures)
+
+                for future in futures_iter:
+                    total_dist += sum(future.result())
+
+        return total_dist / num_combos if num_combos else 0
+
+    @staticmethod
+    def _calculate_tip_distances_batch(tree_pickle, tips_data):
+        """Calculate average distances for a batch of tips."""
+        tree = pickle.loads(tree_pickle)
+        results = []
+
+        for tip, other_tips in tips_data:
+            distances = [tree.distance(tip, other_tip) for other_tip in other_tips]
+            avg_dist = sum(distances) / len(distances) if distances else 0
+            results.append(avg_dist)
+
+        return results
+
+    def calculate_average_distance_of_taxon_to_other_taxa(
+        self,
+        tips: List[str],
+        tree: Newick.Tree,
+    ) -> List[float]:
+        # IMPORTANT: Original code has a bug where it uses set(tip) which creates
+        # a set of characters, not a set containing the tip. This includes the
+        # current tip in distance calculations. We preserve this for compatibility.
+
+        # For small datasets or to maintain exact compatibility, use sequential
+        if len(tips) <= 50:
+            avg_PDis = []
+            for tip in tips:
+                # Preserve the original bug: set(tip) creates set of characters
+                tips_minus_i = list(set(tips) - set(tip))
+                PDi = []
+                for tip_minus in tips_minus_i:
+                    PDi.append(tree.distance(tip, tip_minus))
+                PDi = sum(PDi) / len(PDi) if PDi else 0
+                avg_PDis.append(PDi)
+
+            return avg_PDis
+
+        # For larger datasets, use parallel processing but preserve the bug
+        tips_data = []
+        for tip in tips:
+            # Preserve the bug: set(tip) creates set of characters
+            tips_minus_i = list(set(tips) - set(tip))
+            tips_data.append((tip, tips_minus_i))
+
+        # Process in batches
+        batch_size = max(10, len(tips) // mp.cpu_count())
+        tree_pickle = pickle.dumps(tree)
+
+        with ProcessPoolExecutor(max_workers=min(mp.cpu_count(), 8)) as executor:
+            # Keep track of batch order
+            future_to_index = {}
+
+            for i in range(0, len(tips_data), batch_size):
+                batch = tips_data[i:i + batch_size]
+                future = executor.submit(self._calculate_tip_distances_batch, tree_pickle, batch)
+                future_to_index[future] = i
+
+            # Collect results in order
+            results_dict = {}
+            for future in as_completed(future_to_index):
+                batch_index = future_to_index[future]
+                results_dict[batch_index] = future.result()
+
+        # Reconstruct ordered results
+        avg_PDis = []
+        for i in sorted(results_dict.keys()):
+            avg_PDis.extend(results_dict[i])
+
+        return avg_PDis
+
+    def calculate_lb_score_per_taxa(
+        self,
+        avg_PDis: List[float],
+        avg_dist: float
+    ) -> List[float]:
+        if avg_dist == 0:
+            try:
+                print("Invalid tree. Tree should contain branch lengths")
+                sys.exit(2)
+            except BrokenPipeError:
+                pass
+            return []
+
+        # Use NumPy for vectorized computation
+        PDis_array = np.array(avg_PDis)
+        LBis = ((PDis_array / avg_dist) - 1) * 100
+
+        return LBis.tolist()
+
+    def calculate_lb_score(
+        self,
+        tree: Newick.Tree
+    ) -> Tuple[List[str], List[float]]:
+        tips = self.get_tip_names_from_tree(tree)
+
+        avg_dist = self.calculate_average_distance_between_tips(tips, tree)
+
+        avg_PDis = \
+            self.calculate_average_distance_of_taxon_to_other_taxa(tips, tree)
+
+        LBis = self.calculate_lb_score_per_taxa(avg_PDis, avg_dist)
+
+        return tips, LBis

phykit/services/tree/monophyly_check.py

@@ -0,0 +1,106 @@
+import sys
+from typing import Dict, List, Union
+
+from Bio.Phylo import Newick
+
+from .base import Tree
+
+from ...helpers.stats_summary import calculate_summary_statistics_from_arr
+from ...helpers.files import read_single_column_file_to_list
+
+
+class MonophylyCheck(Tree):
+    def __init__(self, args) -> None:
+        super().__init__(**self.process_args(args))
+
+    def run(self) -> None:
+        tree = self.read_tree_file()
+        taxa = read_single_column_file_to_list(self.list_of_taxa)
+
+        res_arr = []
+
+        # Use frozenset for more efficient set operations
+        tree_tips = frozenset(self.get_tip_names_from_tree(tree))
+        taxa_set = frozenset(taxa)
+        taxa_of_interest = taxa_set.intersection(tree_tips)
+
+        if len(taxa_of_interest) <= 1:
+            res_arr.append(["insufficient_taxon_representation"])
+            sys.exit(2)
+
+        # Convert back to list for functions that need it
+        taxa_of_interest_list = list(taxa_of_interest)
+        shared_tree_tips = self.shared_tips(taxa_of_interest_list, list(tree_tips))
+
+        # Use set difference directly
+        diff_tips = list(tree_tips - frozenset(shared_tree_tips))
+        tree.root_with_outgroup(diff_tips)
+        tree = tree.common_ancestor(shared_tree_tips)
+
+        # Cache common ancestor tips as set
+        common_ancestor_tips = frozenset(self.get_tip_names_from_tree(tree))
+        diff_tips_between_clade_and_curr_tree = list(
+            taxa_of_interest.symmetric_difference(common_ancestor_tips)
+        )
+
+        stats = self.get_bootstrap_statistics(tree)
+
+        res_arr = self.populate_res_arr(
+            diff_tips_between_clade_and_curr_tree, stats, res_arr
+        )
+
+        self.print_results(res_arr)
+
+    def process_args(self, args) -> Dict[str, str]:
+        return dict(
+            tree_file_path=args.tree,
+            list_of_taxa=args.list_of_taxa,
+        )
+
+    def get_bootstrap_statistics(
+        self,
+        clade: Newick.Clade
+    ) -> Dict[str, Union[int, float]]:
+        # Use generator for memory efficiency
+        bs_vals = [
+            terminal.confidence for terminal in clade.get_nonterminals()
+            if terminal.confidence is not None
+        ]
+
+        return calculate_summary_statistics_from_arr(bs_vals)
+
+    def populate_res_arr(
+        self,
+        diff_tips_between_clade_and_curr_tree: List[str],
+        stats: Dict[str, float],
+        res_arr: List,
+    ) -> List[List[Union[str, int, float]]]:
+        temp = []
+
+        if len(diff_tips_between_clade_and_curr_tree) == 0:
+            temp.append("monophyletic")
+        else:
+            temp.append("not_monophyletic")
+        temp.append(stats["mean"])
+        temp.append(stats["maximum"])
+        temp.append(stats["minimum"])
+        temp.append(stats["standard_deviation"])
+        temp.append(diff_tips_between_clade_and_curr_tree)
+        res_arr.append(temp)
+
+        return res_arr
+
+    def print_results(self, res_arr: List[List[Union[str, int, float]]]) -> None:
+        for res in res_arr:
+            try:
+                if res[5]:
+                    res[5].sort()
+                    print(
+                        f"{res[0]}\t{round(res[1], 4)}\t{round(res[2], 4)}\t{round(res[3], 4)}\t{round(res[4], 4)}\t{';'.join(res[5])}"
+                    )
+                else:
+                    print(
+                        f"{res[0]}\t{round(res[1], 4)}\t{round(res[2], 4)}\t{round(res[3], 4)}\t{round(res[4], 4)}"
+                    )
+            except IndexError:
+                print(f"{res[0]}")