pytransdecoder 0.2.1__py3-none-any.whl

pytransdecoder/core/pwm.py

@@ -0,0 +1,174 @@
+"""
+Position weight matrix utilities for start codon refinement.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Sequence, Tuple
+
+
+BASE_ORDER = ("G", "A", "T", "C")
+PSEUDOCOUNT = 0.1
+
+
+@dataclass
+class PWM:
+    """Minimal PWM implementation matching the Perl PWM.pm behavior."""
+
+    pos_freqs: List[Dict[str, int]] = field(default_factory=list)
+    pos_probs: List[Dict[str, float]] = field(default_factory=list)
+    built: bool = False
+
+    def add_feature(self, feature_seq: str) -> None:
+        feature_seq = feature_seq.upper()
+        if any(base not in BASE_ORDER for base in feature_seq):
+            return
+
+        if self.pos_freqs and len(feature_seq) != self.length:
+            raise ValueError(
+                f"PWM length {self.length} does not match feature length {len(feature_seq)}"
+            )
+
+        while len(self.pos_freqs) < len(feature_seq):
+            self.pos_freqs.append({})
+
+        for index, base in enumerate(feature_seq):
+            self.pos_freqs[index][base] = self.pos_freqs[index].get(base, 0) + 1
+
+        self.built = False
+
+    def remove_feature(self, feature_seq: str) -> None:
+        feature_seq = feature_seq.upper()
+        if len(feature_seq) != self.length:
+            raise ValueError(
+                f"PWM length {self.length} does not match feature length {len(feature_seq)}"
+            )
+
+        for index, base in enumerate(feature_seq):
+            current = self.pos_freqs[index].get(base, 0)
+            self.pos_freqs[index][base] = current - 1
+
+        self.built = False
+
+    @property
+    def length(self) -> int:
+        if self.pos_probs:
+            return len(self.pos_probs)
+        return len(self.pos_freqs)
+
+    def build(self) -> None:
+        self.pos_probs = []
+        for pos_freq in self.pos_freqs:
+            total = sum(pos_freq.values())
+            pos_probs = {}
+            for base in BASE_ORDER:
+                count = pos_freq.get(base, 0)
+                pos_probs[base] = (count + PSEUDOCOUNT) / (total + 4 * PSEUDOCOUNT)
+            self.pos_probs.append(pos_probs)
+
+        self.built = True
+
+    def write(self, filename: Path) -> None:
+        if not self.built:
+            self.build()
+
+        with open(filename, "w") as handle:
+            handle.write("pos\tG\tA\tT\tC\n")
+            for index, pos_probs in enumerate(self.pos_probs):
+                handle.write(
+                    f"{index}\t{pos_probs['G']:.6f}\t{pos_probs['A']:.6f}\t"
+                    f"{pos_probs['T']:.6f}\t{pos_probs['C']:.6f}\n"
+                )
+
+    @classmethod
+    def load(cls, filename: Path) -> "PWM":
+        pwm = cls()
+        with open(filename) as handle:
+            header = next(handle, None)
+            if header is None:
+                raise ValueError(f"PWM file is empty: {filename}")
+            for line in handle:
+                line = line.strip()
+                if not line:
+                    continue
+                parts = line.split("\t")
+                if len(parts) != 5:
+                    continue
+                pwm.pos_probs.append(
+                    {
+                        "G": float(parts[1]),
+                        "A": float(parts[2]),
+                        "T": float(parts[3]),
+                        "C": float(parts[4]),
+                    }
+                )
+        pwm.built = True
+        return pwm
+
+    def score_plus_minus(
+        self,
+        target_sequence: str,
+        pwm_minus: "PWM",
+        pwm_range: Optional[Tuple[int, int]] = None,
+    ) -> Optional[float]:
+        target_sequence = target_sequence.upper()
+        if any(base not in BASE_ORDER for base in target_sequence):
+            return None
+        if not self.built or not pwm_minus.built:
+            raise ValueError("Both PWMs must be built before scoring")
+        if len(target_sequence) != self.length or self.length != pwm_minus.length:
+            raise ValueError("Target sequence and PWMs must have matching lengths")
+
+        start, end = (0, self.length - 1) if pwm_range is None else pwm_range
+        motif_score = 0.0
+        for index in range(start, end + 1):
+            base = target_sequence[index]
+            pos_prob = self.pos_probs[index].get(base)
+            neg_prob = pwm_minus.pos_probs[index].get(base)
+            if not pos_prob or not neg_prob:
+                return None
+            motif_score += math.log(pos_prob / neg_prob)
+
+        return motif_score
+
+
+def score_start_window(
+    pwm_plus: PWM, pwm_minus: PWM, feature: str, atg_position: int, up: int, down: int
+) -> Optional[float]:
+    """Length-normalized +/- log-odds score of a start-codon feature.
+
+    Scores `up` bases upstream of the ATG, the ATG itself, and `down` bases downstream,
+    then divides by (up + down). Both PWM training (ROC/threshold selection) and start
+    refinement must score candidates through this function so that the selected
+    threshold is applied on the same scale and window it was learned on.
+    """
+    score = pwm_plus.score_plus_minus(
+        feature, pwm_minus, pwm_range=(atg_position - up, atg_position + 2 + down)
+    )
+    if score is None:
+        return None
+    return score / (up + down)
+
+
+def build_pwm(features: Iterable[str]) -> PWM:
+    pwm = PWM()
+    for feature in features:
+        pwm.add_feature(feature)
+    pwm.build()
+    return pwm
+
+
+def trapezoid_auc(points: Sequence[Tuple[float, float]]) -> float:
+    ordered = sorted(points, key=lambda item: (item[0], item[1]))
+    ordered = [(0.0, 0.0)] + ordered + [(1.0, 1.0)]
+    total_auc = 0.0
+    prev_x, prev_y = ordered[0]
+    for curr_x, curr_y in ordered[1:]:
+        total_auc += ((curr_x - prev_x) * min(prev_y, curr_y)) + (
+            0.5 * (curr_x - prev_x) * abs(curr_y - prev_y)
+        )
+        prev_x, prev_y = curr_x, curr_y
+    return total_auc

pytransdecoder/core/sequence.py

@@ -0,0 +1,19 @@
+"""
+Sequence utilities
+"""
+
+from Bio.Seq import Seq
+
+
+def reverse_complement(sequence: str) -> str:
+    """
+    Return reverse complement of a DNA/RNA sequence.
+    
+    Args:
+        sequence: DNA or RNA sequence
+        
+    Returns:
+        Reverse complement sequence
+    """
+    seq = Seq(sequence)
+    return str(seq.reverse_complement())

pytransdecoder/core/translator.py

@@ -0,0 +1,143 @@
+"""
+Nucleotide to protein translation using BioPython genetic codes.
+
+Replaces Nuc_translator.pm functionality.
+"""
+
+from typing import List, Set
+from Bio.Data import CodonTable
+from Bio.Seq import Seq
+
+
+class Translator:
+    """
+    Handles translation of nucleotide sequences to protein.
+    
+    Supports multiple genetic codes via BioPython's CodonTable.
+    """
+    
+    # Mapping from TransDecoder genetic code names to BioPython table IDs
+    GENETIC_CODE_MAP = {
+        'universal': 1,
+        'standard': 1,
+        'vertebrate_mitochondrial': 2,
+        'yeast_mitochondrial': 3,
+        'mold_mitochondrial': 4,
+        'invertebrate_mitochondrial': 5,
+        'ciliate': 6,
+        'dasycladacean': 6,
+        'hexamita': 6,
+        'echinoderm_mitochondrial': 9,
+        'euplotid': 10,
+        'bacterial': 11,
+        'alternative_yeast': 12,
+        'ascidian_mitochondrial': 13,
+        'flatworm_mitochondrial': 14,
+        'chlorophycean_mitochondrial': 16,
+        'trematode_mitochondrial': 21,
+        'scenedesmus_obliquus_mitochondrial': 22,
+        'thraustochytrium_mitochondrial': 23,
+        'pterobranchia_mitochondrial': 24,
+        'sr1_gracilibacteria': 25,
+        'pachysolen_tannophilus': 26,
+        'candida': 12,  # CUG encodes Ser instead of Leu
+        'acetabularia': 6,
+        'tetrahymena': 6,
+        'mesodinium': 29,  # UAA/UAG encode Tyr
+        'peritrich': 30,   # UAA/UAG encode Glu
+        # names used by the Perl TransDecoder (Nuc_translator.pm)
+        'mitochondrial_vertebrates': 2,
+        'mitochondrial_yeast': 3,
+        'mitochondrial_protozoan': 4,
+        'mitochondrial_invertebrates': 5,
+        'mitochondrial_echinoderm': 9,
+        'mitochondrial_ascidian': 13,
+        'mitochondrial_chlorophycean': 16,
+        'mitochondrial_trematode': 21,
+        'mitochondrial_scenedesmus_obliquus': 22,
+        'mitochondrial_thraustochytrium': 23,
+        'mitochondrial_pterobranchia': 24,
+    }
+    
+    def __init__(self, genetic_code: str = "universal"):
+        """
+        Initialize translator with specified genetic code.
+        
+        Args:
+            genetic_code: Name of genetic code (case-insensitive)
+        """
+        code_name = genetic_code.lower().replace(' ', '_').replace('-', '_')
+        
+        if code_name not in self.GENETIC_CODE_MAP:
+            available = ', '.join(sorted(self.GENETIC_CODE_MAP.keys()))
+            raise ValueError(
+                f"Unknown genetic code: {genetic_code}. "
+                f"Available codes: {available}"
+            )
+        
+        self.genetic_code_name = genetic_code
+        self.table_id = self.GENETIC_CODE_MAP[code_name]
+        self.codon_table = CodonTable.unambiguous_dna_by_id[self.table_id]
+    
+    def get_stop_codons(self) -> List[str]:
+        """
+        Get stop codons for current genetic code.
+        
+        Returns:
+            List of stop codon sequences (uppercase)
+        """
+        return sorted(self.codon_table.stop_codons)
+    
+    def get_start_codons(self, allow_non_met: bool = False) -> List[str]:
+        """
+        Get start codons for current genetic code.
+        
+        Args:
+            allow_non_met: If True, return all possible start codons.
+                          If False, return only ATG (standard start).
+        
+        Returns:
+            List of start codon sequences (uppercase)
+        """
+        if allow_non_met:
+            # Use all start codons from the table
+            return sorted(self.codon_table.start_codons)
+        else:
+            # Standard start codon only
+            return ['ATG']
+    
+    def translate(self, sequence: str, frame: int = 0) -> str:
+        """
+        Translate nucleotide sequence to protein.
+        
+        Args:
+            sequence: DNA/RNA sequence
+            frame: Reading frame offset (0, 1, or 2)
+        
+        Returns:
+            Protein sequence (stops are represented as *)
+        """
+        # Adjust for frame
+        seq = sequence[frame:].upper()
+        
+        # Convert to Bio.Seq and translate
+        bio_seq = Seq(seq)
+        
+        try:
+            protein = str(bio_seq.translate(table=self.table_id, to_stop=False))
+        except Exception as e:
+            # Handle translation errors (e.g., incomplete codons)
+            # Translate as much as possible
+            complete_codons = len(seq) // 3
+            truncated = seq[:complete_codons * 3]
+            if truncated:
+                protein = str(Seq(truncated).translate(table=self.table_id, to_stop=False))
+            else:
+                protein = ""
+        
+        return protein
+    
+    @classmethod
+    def get_available_genetic_codes(cls) -> List[str]:
+        """Get list of supported genetic code names"""
+        return sorted(cls.GENETIC_CODE_MAP.keys())

pytransdecoder/core/writers.py

@@ -0,0 +1,69 @@
+"""
+Output file writers for TransDecoder
+"""
+
+from typing import List, TextIO
+from pathlib import Path
+from .models import ORF
+
+
+class GFF3Writer:
+    """Write ORFs to GFF3 format"""
+    
+    def __init__(self, filepath: Path):
+        self.filepath = filepath
+        self.file: TextIO = None
+    
+    def __enter__(self):
+        self.file = open(self.filepath, 'w')
+        self._write_header()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.file:
+            self.file.close()
+    
+    def _write_header(self):
+        """Write GFF3 header"""
+        self.file.write("##gff-version 3\n")
+    
+    def write_orf(self, orf: ORF):
+        """Write a single ORF"""
+        self.file.write(orf.to_gff3() + "\n")
+
+
+class FastaWriter:
+    """Write sequences to FASTA format"""
+    
+    def __init__(self, filepath: Path):
+        self.filepath = filepath
+        self.file: TextIO = None
+    
+    def __enter__(self):
+        self.file = open(self.filepath, 'w')
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.file:
+            self.file.close()
+    
+    def write_sequence(self, header: str, sequence: str, wrap: int = 60):
+        """
+        Write a sequence in FASTA format.
+        
+        Args:
+            header: FASTA header (should start with >)
+            sequence: Sequence string
+            wrap: Line width for wrapping (0 = no wrap)
+        """
+        if not header.startswith('>'):
+            header = '>' + header
+        
+        self.file.write(header + '\n')
+        
+        if wrap > 0:
+            # Wrap sequence
+            for i in range(0, len(sequence), wrap):
+                self.file.write(sequence[i:i+wrap] + '\n')
+        else:
+            self.file.write(sequence + '\n')