phykit 2.1.0__py3-none-any.whl

phykit/services/alignment/__init__.py

@@ -0,0 +1,17 @@
+from .alignment_length import AlignmentLength
+from .alignment_length_no_gaps import AlignmentLengthNoGaps
+from .alignment_recoding import AlignmentRecoding
+from .column_score import ColumnScore
+from .compositional_bias_per_site import CompositionalBiasPerSite
+from .create_concatenation_matrix import CreateConcatenationMatrix
+from .dna_threader import DNAThreader
+from .evolutionary_rate_per_site import EvolutionaryRatePerSite
+from .faidx import Faidx
+from .gc_content import GCContent
+from .pairwise_identity import PairwiseIdentity
+from .parsimony_informative_sites import ParsimonyInformative
+from .rcv import RelativeCompositionVariability
+from .rcvt import RelativeCompositionVariabilityTaxon
+from .rename_fasta_entries import RenameFastaEntries
+from .sum_of_pairs_score import SumOfPairsScore
+from .variable_sites import VariableSites

phykit/services/alignment/alignment_length.py

@@ -0,0 +1,16 @@
+from .base import Alignment
+
+from typing import Dict
+
+
+class AlignmentLength(Alignment):
+    def __init__(self, args) -> None:
+        super().__init__(**self.process_args(args))
+
+    def run(self) -> None:
+        alignment, _, _ = self.get_alignment_and_format()
+        aln_len = alignment.get_alignment_length()
+        print(aln_len)
+
+    def process_args(self, args) -> Dict[str, str]:
+        return dict(alignment_file_path=args.alignment)

phykit/services/alignment/alignment_length_no_gaps.py

@@ -0,0 +1,69 @@
+from argparse import Namespace
+from typing import Dict, Tuple
+import numpy as np
+
+from Bio.Align import MultipleSeqAlignment
+
+from .base import Alignment
+
+
+class AlignmentLengthNoGaps(Alignment):
+    def __init__(self, args) -> None:
+        super().__init__(**self.process_args(args))
+
+    def run(self) -> None:
+        alignment, _, is_protein = self.get_alignment_and_format()
+        (
+            aln_len_no_gaps,
+            aln_len,
+            aln_len_no_gaps_per,
+        ) = self.calculate_alignment_length_no_gaps(alignment, is_protein)
+        print(f"{aln_len_no_gaps}\t{aln_len}\t{round(aln_len_no_gaps_per, 4)}")
+
+    def process_args(
+        self,
+        args: Namespace,
+    ) -> Dict[str, str]:
+        return dict(alignment_file_path=args.alignment)
+
+    def calculate_alignment_length_no_gaps(
+        self,
+        alignment: MultipleSeqAlignment,
+        is_protein: bool,
+    ) -> Tuple[int, int, float]:
+        aln_len = alignment.get_alignment_length()
+        aln_len_no_gaps = self.get_sites_no_gaps_count(
+            alignment,
+            aln_len,
+            is_protein
+        )
+
+        aln_len_no_gaps_per = (aln_len_no_gaps / aln_len) * 100
+
+        return aln_len_no_gaps, aln_len, aln_len_no_gaps_per
+
+    def get_sites_no_gaps_count(
+        self,
+        alignment: MultipleSeqAlignment,
+        aln_len: int,
+        is_protein: bool,
+    ) -> int:
+        """
+        Count sites in the alignment with no gaps
+        """
+        gap_chars = set(self.get_gap_chars())
+
+        # Convert alignment to numpy array
+        alignment_array = np.array([
+            list(str(record.seq)) for record in alignment
+        ], dtype='U1')
+
+        # Count columns with no gaps
+        aln_len_no_gaps = 0
+        for col_idx in range(aln_len):
+            column = alignment_array[:, col_idx]
+            # Check if column has any gap characters
+            if not np.any(np.isin(column, list(gap_chars))):
+                aln_len_no_gaps += 1
+
+        return aln_len_no_gaps

phykit/services/alignment/alignment_recoding.py

@@ -0,0 +1,89 @@
+from os import path
+import sys
+from typing import Dict, List
+
+from Bio.Align import MultipleSeqAlignment
+
+from .base import Alignment
+
+here = path.dirname(__file__)
+
+
+class AlignmentRecoding(Alignment):
+    def __init__(self, args) -> None:
+        super().__init__(**self.process_args(args))
+
+    def run(self) -> None:
+        alignment, _, is_protein = self.get_alignment_and_format()
+
+        recoding_table = self.read_recoding_table(self.code[0])
+
+        recoded_alignment = self.recode_alignment(
+            alignment, recoding_table, is_protein
+        )
+
+        for k, v in recoded_alignment.items():
+            print(f">{k}\n{''.join(v)}")
+
+    def recode_alignment(
+        self,
+        alignment: MultipleSeqAlignment,
+        recoding_table: Dict[str, str],
+        is_protein: bool,
+    ) -> Dict[str, List[str]]:
+
+        gap_chars = self.get_gap_chars()
+        recoded_alignment = dict()
+
+        for record in alignment:
+            recoded_sequence = [
+                recoding_table.get(base.upper(), base)
+                if base not in gap_chars else base
+                for base in record.seq
+            ]
+            recoded_alignment[record.id] = recoded_sequence
+
+        return recoded_alignment
+
+    def read_recoding_table(
+        self,
+        recoding: str
+    ) -> Dict[str, str]:
+        """
+        return translation table with codons as keys and amino acids as values
+        """
+
+        recoding_table = dict()
+
+        if recoding is None:
+            print("Please specify a recoding table")
+            sys.exit(2)
+
+        recoding_paths = {
+            "RY-nucleotide": "../../recoding_tables/RY-nucleotide.txt",
+            "SandR-6": "../../recoding_tables/S_and_R-6.txt",
+            "KGB-6": "../../recoding_tables/KGB-6.txt",
+            "Dayhoff-6": "../../recoding_tables/Dayhoff-6.txt",
+            "Dayhoff-9": "../../recoding_tables/Dayhoff-9.txt",
+            "Dayhoff-12": "../../recoding_tables/Dayhoff-12.txt",
+            "Dayhoff-15": "../../recoding_tables/Dayhoff-15.txt",
+            "Dayhoff-18": "../../recoding_tables/Dayhoff-18.txt",
+        }
+        pathing = recoding_paths.get(recoding, str(recoding))
+
+        try:
+            with open(path.join(here, pathing)) as code:
+                for line in code:
+                    parts = line.split()
+                    recoding_table[parts[1].upper()] = parts[0].upper()
+        except FileNotFoundError:
+            print(f"Recoding table file '{pathing}' not found.")
+            sys.exit(2)
+
+        return recoding_table
+
+    def process_args(self, args):
+        return dict(
+            alignment_file_path=args.alignment,
+            code=args.code
+        )

phykit/services/alignment/base.py

@@ -0,0 +1,103 @@
+from collections import Counter
+import sys
+import numpy as np
+
+from typing import List
+
+from ..base import BaseService
+from ...helpers.files import (
+    get_alignment_and_format as get_alignment_and_format_helper
+)
+
+
+class Alignment(BaseService):
+    def __init__(
+        self,
+        *args,
+        alignment_file_path=None,
+        code=None,
+        fasta=None,
+        output_file_path=None,
+        protein_file_path=None,
+        nucleotide_file_path=None,
+        alignment_list_path=None,
+        prefix=None,
+        idmap=None,
+        reference=None,
+        verbose=None,
+        entry=None,
+        exclude_gaps=None,
+    ):
+        self.alignment_file_path = alignment_file_path
+        self.code = code,
+        self.output_file_path = output_file_path
+        self.protein_file_path = (protein_file_path,)
+        self.nucleotide_file_path = nucleotide_file_path
+        self.alignment_list_path = alignment_list_path
+        self.prefix = prefix
+        self.fasta = fasta
+        self.idmap = idmap
+        self.reference = reference
+        self.verbose = verbose
+        self.entry = entry
+        self.exclude_gaps = exclude_gaps
+
+    def get_alignment_and_format(self):
+        """
+        automatic file type determination
+        """
+        try:
+            return get_alignment_and_format_helper(self.alignment_file_path)
+        except FileNotFoundError:
+            print("Input corresponds to no such file or directory.")
+            print("Please double check pathing and filenames")
+            sys.exit(2)
+
+    def calculate_rcv(self) -> float:
+        alignment, _, _ = self.get_alignment_and_format()
+        aln_len = alignment.get_alignment_length()
+        num_records = len(alignment)
+
+        # Convert alignment to numpy array for faster operations
+        alignment_array = np.array([
+            list(str(record.seq)) for record in alignment
+        ], dtype='U1')
+
+        # Get all unique characters in the alignment
+        unique_chars = np.unique(alignment_array)
+
+        # Vectorized approach: create a count matrix for all sequences and characters at once
+        # Shape: (num_records, num_unique_chars)
+        count_matrix = np.zeros((num_records, len(unique_chars)), dtype=np.int32)
+
+        # Build character index mapping for fast lookup
+        char_to_idx = {char: idx for idx, char in enumerate(unique_chars)}
+
+        # Count characters for each sequence using vectorized operations
+        for seq_idx in range(num_records):
+            seq = alignment_array[seq_idx]
+            for char_idx, char in enumerate(unique_chars):
+                count_matrix[seq_idx, char_idx] = np.sum(seq == char)
+
+        # Calculate total counts and averages using matrix operations
+        total_counts = np.sum(count_matrix, axis=0)
+        average_counts = total_counts / num_records
+
+        # Calculate RCV values using vectorized operations
+        # Compute absolute differences from average for all sequences at once
+        abs_diffs = np.abs(count_matrix - average_counts)
+
+        # Sum across characters for each sequence
+        seq_rcv_sums = np.sum(abs_diffs, axis=1)
+
+        # Normalize and sum
+        indiv_rcv_values = seq_rcv_sums / (num_records * aln_len)
+        relative_composition_variability = np.sum(indiv_rcv_values)
+
+        return float(relative_composition_variability)
+
+    def get_gap_chars(is_protein: bool) -> List[str]:
+        if is_protein:
+            return ["-", "?", "*", "X", "x"]
+        else:
+            return ["-", "?", "*", "X", "x", "N", "n"]

phykit/services/alignment/column_score.py

@@ -0,0 +1,66 @@
+from typing import Dict, List, Tuple
+import numpy as np
+
+from Bio import AlignIO
+from Bio.Align import MultipleSeqAlignment
+
+from .base import Alignment
+
+
+class ColumnScore(Alignment):
+    def __init__(self, args) -> None:
+        super().__init__(**self.process_args(args))
+
+    def run(self) -> None:
+        query_records = AlignIO.read(self.fasta, "fasta")
+        reference_records = AlignIO.read(self.reference, "fasta")
+
+        # create lists with strings of every columns
+        ref_columns, query_columns = self.get_columns_from_alignments(
+            reference_records, query_records
+        )
+
+        # count the number of matches and total pairs
+        number_of_matches, number_of_total_columns = \
+            self.calculate_matches_between_ref_and_query_columns(
+                ref_columns, query_columns
+            )
+
+        print(round(number_of_matches / number_of_total_columns, 4))
+
+    def process_args(self, args) -> Dict[str, str]:
+        return dict(fasta=args.fasta, reference=args.reference)
+
+    def get_columns_from_alignments(
+        self,
+        reference_records: MultipleSeqAlignment,
+        query_records: MultipleSeqAlignment,
+    ) -> Tuple[List[str], List[str]]:
+        # Convert alignments to numpy arrays for faster column extraction
+        ref_array = np.array([
+            [c.upper() for c in str(record.seq)]
+            for record in reference_records
+        ], dtype='U1')
+
+        query_array = np.array([
+            [c.upper() for c in str(record.seq)]
+            for record in query_records
+        ], dtype='U1')
+
+        # Extract columns as strings
+        ref_columns = [''.join(ref_array[:, i]) for i in range(ref_array.shape[1])]
+        query_columns = [''.join(query_array[:, i]) for i in range(query_array.shape[1])]
+
+        return ref_columns, query_columns
+
+    def calculate_matches_between_ref_and_query_columns(
+        self,
+        ref_columns: List[str],
+        query_columns: List[str],
+    ) -> Tuple[int, int]:
+        set1 = set(ref_columns)
+        set2 = set(query_columns)
+
+        matches = set1.intersection(set2)
+
+        return len(matches), len(query_columns)

phykit/services/alignment/compositional_bias_per_site.py

@@ -0,0 +1,98 @@
+from typing import Dict, List, Tuple, Union
+from collections import Counter
+import numpy as np
+
+from scipy.stats import chisquare, false_discovery_control
+from scipy.stats._stats_py import Power_divergenceResult
+from Bio.Align import MultipleSeqAlignment
+
+from .base import Alignment
+
+
+class CompositionalBiasPerSite(Alignment):
+    def __init__(self, args) -> None:
+        super().__init__(**self.process_args(args))
+
+    def run(self) -> None:
+        alignment, _, is_protein = self.get_alignment_and_format()
+
+        stat_res, p_vals_corrected = \
+            self.calculate_compositional_bias_per_site(alignment)
+
+        for idx, (stat_info, pval_cor) in enumerate(
+            zip(stat_res, p_vals_corrected), start=1
+        ):
+            pval_cor_str = "nan" if isinstance(pval_cor, str) else round(pval_cor, 4)
+            print(f"{idx}\t{round(stat_info.statistic, 4)}\t{pval_cor_str}\t{round(stat_info.pvalue, 4)}")
+
+    def process_args(self, args) -> Dict[str, str]:
+        return dict(alignment_file_path=args.alignment)
+
+    def get_number_of_occurrences_per_character(
+        self,
+        alignment: MultipleSeqAlignment,
+        idx: int,
+    ) -> List[int]:
+        gap_chars = self.get_gap_chars()
+        seq_at_position = alignment[:, idx].upper()
+        filtered_seq = "".join([char for char in seq_at_position if char not in gap_chars])
+
+        return list(Counter(filtered_seq).values())
+
+    def calculate_compositional_bias_per_site(
+        self,
+        alignment: MultipleSeqAlignment,
+    ) -> Tuple[
+        List[Power_divergenceResult],
+        List[Union[float, str]],
+    ]:
+        aln_len = alignment.get_alignment_length()
+        gap_chars = set(self.get_gap_chars())
+
+        # Convert alignment to numpy array for faster operations
+        alignment_array = np.array([
+            [c.upper() for c in str(record.seq)]
+            for record in alignment
+        ], dtype='U1')
+
+        stat_res = []
+        p_vals = []
+        nan_idx = []
+
+        # Process each column
+        for col_idx in range(aln_len):
+            column = alignment_array[:, col_idx]
+
+            # Filter out gaps
+            non_gap_mask = ~np.isin(column, list(gap_chars))
+            filtered_column = column[non_gap_mask]
+
+            if len(filtered_column) > 0:
+                # Count occurrences using numpy
+                unique_chars, counts = np.unique(filtered_column, return_counts=True)
+
+                # Perform chi-square test
+                chisquare_res = chisquare(counts)
+                stat_res.append(chisquare_res)
+
+                if not np.isnan(chisquare_res.pvalue):
+                    p_vals.append(chisquare_res.pvalue)
+                else:
+                    nan_idx.append(col_idx)
+            else:
+                # Handle empty column
+                dummy_res = chisquare([1])  # Create dummy result
+                stat_res.append(dummy_res)
+                nan_idx.append(col_idx)
+
+        # Apply FDR correction
+        if p_vals:
+            p_vals_corrected = list(false_discovery_control(p_vals))
+        else:
+            p_vals_corrected = []
+
+        # Insert NaNs at appropriate positions
+        for idx in reversed(nan_idx):
+            p_vals_corrected.insert(idx, "nan")
+
+        return stat_res, p_vals_corrected