pytransdecoder 0.2.1__tar.gz → 0.3.0__tar.gz

{pytransdecoder-0.2.1/pytransdecoder.egg-info → pytransdecoder-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytransdecoder
-Version: 0.2.1
+Version: 0.3.0
 Summary: TransDecoder, the original Perl version ported to Python by AI/LLMs with new features integrated
 Author: Brian Haas, ported to python by AI/LLMs
 License: BSD-3-Clause
@@ -10,6 +10,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: biopython>=1.81
+Requires-Dist: numpy>=1.21
 Requires-Dist: tqdm>=4.65
 Provides-Extra: dev
 Requires-Dist: pytest>=7.4; extra == "dev"
@@ -178,6 +179,8 @@ pyTransdecoder -t transcripts.fasta --pfam-search-db Pfam-A.hmm
 --decoy-seed INT                  Seed of the decoy shuffles (default: 42)
 --preset NAME|DIR                 Models and thresholds from a preset instead of the input
                                   (recommended below ~1,000 transcripts or for mostly partial sets)
+--cpu INT                         Worker processes for scoring candidate and decoy ORFs
+                                  (default: 1); the output does not depend on it
 -G, --genetic-code TEXT           Genetic code (default: Standard)
 -v, --verbose                     Verbose output
 ```
@@ -302,6 +305,7 @@ diff ../TransDecoder/test.fasta.transdecoder_dir/longest_orfs.pep \
 
 - Python 3.8+
 - BioPython >= 1.81
+- NumPy >= 1.21
 - tqdm >= 4.65
 
 **Note**: Ported by Claude.io Sonnet 4.5 under guidance by bhaas. Jan 24, 2026.

{pytransdecoder-0.2.1 → pytransdecoder-0.3.0}/README.md

@@ -158,6 +158,8 @@ pyTransdecoder -t transcripts.fasta --pfam-search-db Pfam-A.hmm
 --decoy-seed INT                  Seed of the decoy shuffles (default: 42)
 --preset NAME|DIR                 Models and thresholds from a preset instead of the input
                                   (recommended below ~1,000 transcripts or for mostly partial sets)
+--cpu INT                         Worker processes for scoring candidate and decoy ORFs
+                                  (default: 1); the output does not depend on it
 -G, --genetic-code TEXT           Genetic code (default: Standard)
 -v, --verbose                     Verbose output
 ```
@@ -282,6 +284,7 @@ diff ../TransDecoder/test.fasta.transdecoder_dir/longest_orfs.pep \
 
 - Python 3.8+
 - BioPython >= 1.81
+- NumPy >= 1.21
 - tqdm >= 4.65
 
 **Note**: Ported by Claude.io Sonnet 4.5 under guidance by bhaas. Jan 24, 2026.

{pytransdecoder-0.2.1 → pytransdecoder-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytransdecoder"
-version = "0.2.1"
+version = "0.3.0"
 description = "TransDecoder, the original Perl version ported to Python by AI/LLMs with new features integrated"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -14,6 +14,7 @@ authors = [
 ]
 dependencies = [
     "biopython>=1.81",
+    "numpy>=1.21",
     "tqdm>=4.65",
 ]
 

{pytransdecoder-0.2.1 → pytransdecoder-0.3.0}/pytransdecoder/__init__.py

@@ -4,4 +4,4 @@ PyTransDecoder - Python port of TransDecoder
 Identifies candidate protein-coding regions within transcript sequences.
 """
 
-__version__ = "0.2.1"
+__version__ = "0.3.0"

{pytransdecoder-0.2.1 → pytransdecoder-0.3.0}/pytransdecoder/cli.py

@@ -106,6 +106,9 @@ def _add_selection_args(parser):
                              "(~20 Mb of decoy sequence, at most 50)")
     parser.add_argument('--decoy-seed', type=int, default=DEFAULT_DECOY_SEED, dest='decoy_seed',
                         help="Seed of the decoy shuffles (default: %(default)s)")
+    parser.add_argument('--cpu', type=int, default=1, dest='cpu',
+                        help="Worker processes for scoring candidate and decoy ORFs; results do not depend "
+                             "on it (default: %(default)s)")
     from .core.presets import bundled_presets
     parser.add_argument('--preset', default=None,
                         help="Use a preset's coding model, start model and q-value thresholds instead of "
@@ -330,6 +333,7 @@ def predict_cmd(args):
             decoy_seed=args.decoy_seed,
             preset=args.preset,
             homology_start_assist=args.homology_start_assist,
+            cpu=args.cpu,
         )
         predictor.run()
     except Exception as e:
@@ -607,6 +611,7 @@ def pipeline_cmd(args):
             decoy_seed=args.decoy_seed,
             preset=args.preset,
             homology_start_assist=args.homology_start_assist,
+            cpu=args.cpu,
         )
         predictor.run()
     except Exception as e:

{pytransdecoder-0.2.1 → pytransdecoder-0.3.0}/pytransdecoder/core/base_freqs.py

@@ -19,11 +19,12 @@ def compute_base_counts(fasta_file: str, top_strand_only: bool = False) -> Dict[
     complement = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}
     counts = {base: 0 for base in 'ACGT'}
     for record in read_fasta(fasta_file):
-        for base in str(record.seq).upper():
-            if base in counts:
-                counts[base] += 1
-                if not top_strand_only:
-                    counts[complement[base]] += 1
+        seq = str(record.seq).upper()
+        for base in 'ACGT':
+            k = seq.count(base)
+            counts[base] += k
+            if not top_strand_only:
+                counts[complement[base]] += k
     return counts
 
 

{pytransdecoder-0.2.1 → pytransdecoder-0.3.0}/pytransdecoder/core/decoys.py

@@ -55,13 +55,11 @@ def dinucleotide_shuffle(seq: str, rng: Xoshiro128ss) -> str:
         if v in last:
             out.append(last[v])
         order[v] = out
-    pos = defaultdict(int)
+    nxt_of = {v: iter(o).__next__ for v, o in order.items()}  # each edge list consumed in order
     res, u = [seq[0]], seq[0]
     for _ in range(n - 1):
-        w = order[u][pos[u]]
-        pos[u] += 1
-        res.append(w)
-        u = w
+        u = nxt_of[u]()
+        res.append(u)
     return "".join(res)
 
 

pytransdecoder-0.3.0/pytransdecoder/core/markov_fast.py

@@ -0,0 +1,107 @@
+"""
+Framed 5th-order Markov scoring with NumPy, bit-identical to the reference loop
+(core/parallel.score_markov).
+
+The reference adds, for i = 0 .. n-1, the score of the framed k-mer ending at i
+(k = min(i, 5) + 1, frame i % 3) to a running total that starts at 0.0, and stops
+before a terminal in-frame stop codon. Here the per-position values are gathered
+with array lookups, and the total is formed by np.add.accumulate over
+[0.0, v0, v1, ...], which performs the same IEEE additions in the same order.
+Positions 0-4 (k-mers shorter than 6) use the dict, as in the reference.
+
+Only score tables whose keys are all ^[ACGT]{1,6}-[012]$ can be compiled; for any
+other table, compile() returns None and callers use the reference loop.
+"""
+
+import re
+from typing import Dict, Optional, Sequence, Tuple
+
+import numpy as np
+
+_KEY = re.compile(r"^[ACGT]{1,6}-[012]$")
+_CODE = np.full(256, 4, dtype=np.int64)
+for _i, _b in enumerate("ACGT"):
+    _CODE[ord(_b)] = _i
+_POW = (1024, 256, 64, 16, 4, 1)
+INVALID = 4096  # index of the zero slot: 6-mers with a non-ACGT base
+
+
+class MarkovTable:
+    """Hexamer scores of one model, as a (3, 4097) array plus the dict for short k-mers."""
+
+    def __init__(self, scores: Dict[str, float], stop_codons):
+        self.scores = scores
+        self.stop_codons = stop_codons
+        tbl = np.zeros((3, INVALID + 1), dtype=np.float64)
+        for key, v in scores.items():
+            kmer, fr = key[:-2], int(key[-1])
+            if len(kmer) == 6:
+                idx = 0
+                for b, p in zip(kmer, _POW):
+                    idx += "ACGT".index(b) * p
+                tbl[fr, idx] = v
+        self.tbl = tbl
+
+    # -- helpers -------------------------------------------------------------------
+    @staticmethod
+    def _hexamer_index(seq: str) -> np.ndarray:
+        """idx[t] = base-4 index of seq[t:t+6], or INVALID if it contains a non-ACGT base."""
+        c = _CODE[np.frombuffer(seq.encode("latin-1"), dtype=np.uint8)]
+        n = len(c)
+        bad = c == 4
+        cc = np.where(bad, 0, c)
+        m = n - 5
+        idx = cc[0:m] * 1024
+        badw = bad[0:m].copy()
+        for j in range(1, 6):
+            idx += cc[j:m + j] * _POW[j]
+            badw |= bad[j:m + j]
+        idx[badw] = INVALID
+        return idx
+
+    def _score_offsets(self, seq: str, idx: Optional[np.ndarray], offsets: Sequence[int]) -> Tuple[float, ...]:
+        """Reference score of seq[k:] for each k in offsets (idx: _hexamer_index(seq) or None)."""
+        n_full = len(seq)
+        get = self.scores.get
+        tail_stop = seq[n_full - 3:] in self.stop_codons
+        out = []
+        for k in offsets:
+            n = n_full - k
+            if n < 6:
+                out.append(0.0)
+                continue
+            m = n - 3 if (n % 3 == 0 and tail_stop) else n  # positions scored: 0 .. m-1
+            ms = min(m, 5)
+            vals = np.empty(m + 1, dtype=np.float64)
+            vals[0] = 0.0
+            for i in range(ms):
+                vals[i + 1] = get(f"{seq[k:k + i + 1]}-{i % 3}", 0.0)
+            if m > 5:
+                # positions i = 5 .. m-1 of seq[k:], i.e. 6-mers seq[k+i-5 : k+i+1] = idx[k+i-5]
+                t = idx[k:k + m - 5]
+                fr = (np.arange(5, m)) % 3
+                vals[6:] = self.tbl[fr, t]
+            out.append(float(np.add.accumulate(vals)[-1]))
+        return tuple(out)
+
+    # -- public --------------------------------------------------------------------
+    def score(self, seq: str) -> float:
+        if len(seq) < 6:
+            return 0.0
+        return self._score_offsets(seq, self._hexamer_index(seq), (0,))[0]
+
+    def forward_frames(self, seq: str) -> Tuple[float, float, float]:
+        """Scores of seq, seq[1:], seq[2:]."""
+        idx = self._hexamer_index(seq) if len(seq) >= 6 else None
+        return self._score_offsets(seq, idx, (0, 1, 2))
+
+    def six_frames(self, seq: str, rev: str) -> Tuple[float, ...]:
+        """Scores of seq, seq[1:], seq[2:], rev, rev[1:], rev[2:] (rev = reverse complement)."""
+        return self.forward_frames(seq) + self.forward_frames(rev)
+
+
+def compile_table(scores: Dict[str, float], stop_codons) -> Optional[MarkovTable]:
+    """MarkovTable for a score dict, or None if any key is outside ^[ACGT]{1,6}-[012]$."""
+    if not all(_KEY.match(k) for k in scores):
+        return None
+    return MarkovTable(scores, stop_codons)

{pytransdecoder-0.2.1 → pytransdecoder-0.3.0}/pytransdecoder/core/orf_finder.py

@@ -4,6 +4,8 @@ ORF (Open Reading Frame) finder
 Replicates the core algorithm from Longest_orf.pm
 """
 
+import bisect
+import re
 from typing import List, Dict, Tuple
 from .models import ORF
 from .translator import Translator
@@ -54,6 +56,9 @@ class ORFFinder:
         self.translator = Translator(genetic_code)
         self.stop_codons = set(self.translator.get_stop_codons())
         self.start_codons = set(self.translator.get_start_codons(allow_non_met_starts))
+        # overlapping matches of any stop / start codon (positions in all three frames)
+        self._stop_re = re.compile("(?=(" + "|".join(sorted(map(re.escape, self.stop_codons))) + "))")
+        self._start_re = re.compile("(?=(" + "|".join(sorted(map(re.escape, self.start_codons))) + "))")
     
     def find_all_orfs(self, sequence: str, seq_id: str) -> List[ORF]:
         """
@@ -91,13 +96,21 @@ class ORFFinder:
         sequence = sequence.upper()
         orfs = []
         
+        # Codon positions in all frames from one scan each (ascending), split by frame
+        stop_pos = [[], [], []]
+        for m in self._stop_re.finditer(sequence):
+            stop_pos[m.start() % 3].append(m.start())
+        start_pos = [[], [], []]
+        for m in self._start_re.finditer(sequence):
+            start_pos[m.start() % 3].append(m.start())
+
         # Find stops and starts for each frame
         for frame in range(3):
             # Find all stop codons in this frame
-            stops, real_stops = self._find_stops_in_frame(sequence, frame)
+            stops, real_stops = self._find_stops_in_frame(sequence, frame, stop_pos[frame])
             
             # Find all start codons in this frame (passing real_stops to avoid starts at stop positions)
-            starts = self._find_starts_in_frame(sequence, frame, real_stops)
+            starts = self._find_starts_in_frame(sequence, frame, real_stops, start_pos[frame])
             
             # Build ORFs from start-stop pairs
             orfs.extend(
@@ -108,7 +121,7 @@ class ORFFinder:
         
         return orfs
     
-    def _find_stops_in_frame(self, sequence: str, frame: int) -> Tuple[List[int], set]:
+    def _find_stops_in_frame(self, sequence: str, frame: int, positions: List[int] = None) -> Tuple[List[int], set]:
         """
         Find all stop codon positions in a specific frame.
         
@@ -117,14 +130,10 @@ class ORFFinder:
                 - all_stops: List of all stop positions (real + implicit)
                 - real_stop_set: Set of positions that are actual stop codons
         """
-        stops = []
-        real_stops = set()
-        
-        for i in range(frame, len(sequence) - 2, 3):
-            codon = sequence[i:i+3]
-            if codon in self.stop_codons:
-                stops.append(i)
-                real_stops.add(i)
+        if positions is None:  # stop codons at frame, frame+3, ... (ascending)
+            positions = [i for i in range(frame, len(sequence) - 2, 3) if sequence[i:i+3] in self.stop_codons]
+        stops = list(positions)
+        real_stops = set(positions)
         
         # Add implicit stops at end for 3' partials (NOT real stop codons)
         # Perl adds seq_length, seq_length-1, seq_length-2 as implicit stops
@@ -137,7 +146,8 @@ class ORFFinder:
         
         return stops, real_stops
     
-    def _find_starts_in_frame(self, sequence: str, frame: int, real_stops: set) -> List[int]:
+    def _find_starts_in_frame(self, sequence: str, frame: int, real_stops: set,
+                              positions: List[int] = None) -> List[int]:
         """
         Find all start codon positions in a specific frame.
         
@@ -157,10 +167,9 @@ class ORFFinder:
             starts.append(frame)
         
         # Find explicit start codons
-        for i in range(frame, len(sequence) - 2, 3):
-            codon = sequence[i:i+3]
-            if codon in self.start_codons:
-                starts.append(i)
+        if positions is None:
+            positions = [i for i in range(frame, len(sequence) - 2, 3) if sequence[i:i+3] in self.start_codons]
+        starts.extend(positions)
         
         return starts
     
@@ -189,6 +198,11 @@ class ORFFinder:
         """
         orfs = []
         last_used_stop = -1  # Track the last stop position used in this frame
+        # stops = real stop positions (ascending, all in this frame) + implicit end positions;
+        # every start is in this frame too, so the first listed stop after a start is the first
+        # real stop after it (bisect), else the first matching implicit position
+        n_real = len(real_stops)
+        real_sorted = stops[:n_real]
         
         # Iterate through starts in order
         for start_pos in starts:
@@ -199,11 +213,15 @@ class ORFFinder:
             
             # Find the first valid stop after this start (Perl's algorithm)
             valid_stop = None
-            for stop_pos in stops:
-                if (stop_pos > start_pos and 
-                    (stop_pos - start_pos) % 3 == 0):
-                    valid_stop = stop_pos
-                    break  # Take first valid stop (replicates Perl's 'last')
+            k = bisect.bisect_right(real_sorted, start_pos)
+            if k < n_real and (real_sorted[k] - start_pos) % 3 == 0:
+                valid_stop = real_sorted[k]
+            else:  # the original scan; stops before index k are <= start_pos and cannot match
+                for stop_pos in stops[k:]:
+                    if (stop_pos > start_pos and
+                            (stop_pos - start_pos) % 3 == 0):
+                        valid_stop = stop_pos
+                        break  # Take first valid stop (replicates Perl's 'last')
             
             if valid_stop is None:
                 continue

pytransdecoder-0.3.0/pytransdecoder/core/parallel.py

@@ -0,0 +1,133 @@
+"""
+Multi-process scoring of candidate and decoy ORFs.
+
+Both loops are CPU-bound pure Python, so they use worker processes (threads would be serialised by the
+GIL). Each worker runs the same per-ORF arithmetic as the single-process code. Work is split into chunks
+in input order, and results are put back together in that order, so the output does not depend on the
+number of workers.
+"""
+
+from concurrent.futures import ProcessPoolExecutor
+import multiprocessing as mp
+from typing import Dict, FrozenSet, List, Sequence, Tuple
+
+from pytransdecoder.core.sequence import reverse_complement
+
+MARKOV_ORDER = 5
+
+# per-worker state, set by _init_worker (inherited on fork, or passed on spawn)
+_HEX: Dict[str, float] = {}
+_STOPS: FrozenSet[str] = frozenset()
+_FINDER_ARGS: dict = {}
+_TABLE = None  # core/markov_fast.MarkovTable of _HEX, or None (reference loop)
+
+
+def score_markov(sequence: str, markov_order: int, scores: Dict[str, float], stop_codons) -> float:
+    """Sum of framed k-mer log-likelihoods; a terminal in-frame stop codon is not scored."""
+    seq_length = len(sequence)
+    if seq_length < markov_order + 1:
+        return 0.0
+    total_score = 0.0
+    for i in range(seq_length):
+        frame = i % 3
+        markov_use = min(i, markov_order)
+        kmer = sequence[i - markov_use:i + 1]
+        if i == seq_length - 3 and frame == 0:
+            if sequence[i:i + 3] in stop_codons:
+                break
+        total_score += scores.get(f"{kmer}-{frame}", 0.0)
+    return total_score
+
+
+def _init_worker(hex_scores, stop_codons, finder_args):
+    global _HEX, _STOPS, _FINDER_ARGS, _TABLE
+    from pytransdecoder.core.markov_fast import compile_table
+    _HEX, _STOPS, _FINDER_ARGS = hex_scores, stop_codons, finder_args
+    _TABLE = compile_table(hex_scores, stop_codons)
+
+
+def _score_six_frames(sequence: str) -> Tuple[float, ...]:
+    rev = reverse_complement(sequence)
+    if _TABLE is not None:
+        return _TABLE.six_frames(sequence, rev)
+    return tuple(score_markov(s, MARKOV_ORDER, _HEX, _STOPS)
+                 for s in (sequence, sequence[1:], sequence[2:], rev, rev[1:], rev[2:]))
+
+
+def _six_frame_chunk(seqs: Sequence[str]) -> List[Tuple[float, ...]]:
+    return [_score_six_frames(s) for s in seqs]
+
+
+def _decoy_chunk(args):
+    """Decoy ORFs of a chunk of (tid, seq) in the given order: (n_decoy, [(stratum, contrast), ...])."""
+    from pytransdecoder.core import decoys
+    from pytransdecoder.core.prng import Xoshiro128ss
+    from pytransdecoder.core.orf_finder import ORFFinder
+    items, n_shuf, seed = args
+    finder = ORFFinder(**_FINDER_ARGS)
+    n_decoy, out = 0, []
+    for tid, seq in items:
+        for k in range(n_shuf):
+            shuf = decoys.dinucleotide_shuffle(seq, Xoshiro128ss(f"{seed}:{tid}:{k}"))
+            for orf in finder.find_all_orfs(shuf, f"decoy{k}_{tid}"):
+                n_decoy += 1
+                cds = orf.sequence.upper()
+                if _TABLE is not None:
+                    s0, s1, s2 = (round(x, 2) for x in _TABLE.forward_frames(cds))
+                else:
+                    s0 = round(score_markov(cds, MARKOV_ORDER, _HEX, _STOPS), 2)
+                    s1 = round(score_markov(cds[1:], MARKOV_ORDER, _HEX, _STOPS), 2)
+                    s2 = round(score_markov(cds[2:], MARKOV_ORDER, _HEX, _STOPS), 2)
+                c = s0 - max(s1, s2)
+                if s0 > 0 and c > 0:
+                    out.append((decoys.stratum(len(cds) // 3, len(seq), orf.orf_type == 'complete',
+                                               'len_tx_type'), c))
+    return n_decoy, out
+
+
+def _chunks_by_size(items, sizes, n_chunks):
+    """Consecutive chunks of roughly equal total size (order preserved)."""
+    total = sum(sizes) or 1
+    target = total / n_chunks
+    chunks, cur, acc = [], [], 0
+    for it, sz in zip(items, sizes):
+        cur.append(it)
+        acc += sz
+        if acc >= target:
+            chunks.append(cur)
+            cur, acc = [], 0
+    if cur:
+        chunks.append(cur)
+    return chunks
+
+
+def _pool(cpu, hex_scores, stop_codons, finder_args=None):
+    ctx = mp.get_context("fork") if "fork" in mp.get_all_start_methods() else None
+    return ProcessPoolExecutor(max_workers=cpu, mp_context=ctx, initializer=_init_worker,
+                               initargs=(hex_scores, stop_codons, finder_args or {}))
+
+
+def score_six_frames(seqs: List[str], hex_scores, stop_codons, cpu: int) -> List[Tuple[float, ...]]:
+    """Six-frame scores of each sequence, in input order."""
+    if cpu <= 1 or len(seqs) < 2:
+        _init_worker(hex_scores, stop_codons, {})
+        return _six_frame_chunk(seqs)
+    # many small chunks so slow chunks (long ORFs) do not leave workers idle
+    chunks = _chunks_by_size(seqs, [len(s) for s in seqs], cpu * 16)
+    with _pool(cpu, hex_scores, stop_codons) as ex:
+        return [r for part in ex.map(_six_frame_chunk, chunks) for r in part]
+
+
+def decoy_scores(transcripts: List[Tuple[str, str]], n_shuf: int, seed: int, hex_scores, stop_codons,
+                 finder_args: dict, cpu: int):
+    """(n_decoy, eligible decoy (stratum, contrast) list) over transcripts in the given order."""
+    if cpu <= 1:
+        _init_worker(hex_scores, stop_codons, finder_args)
+        return _decoy_chunk((transcripts, n_shuf, seed))
+    chunks = _chunks_by_size(transcripts, [len(s) for _, s in transcripts], cpu * 16)
+    n_decoy, out = 0, []
+    with _pool(cpu, hex_scores, stop_codons, finder_args) as ex:
+        for n, part in ex.map(_decoy_chunk, [(c, n_shuf, seed) for c in chunks]):
+            n_decoy += n
+            out.extend(part)
+    return n_decoy, out

{pytransdecoder-0.2.1 → pytransdecoder-0.3.0}/pytransdecoder/core/prng.py

@@ -48,7 +48,30 @@ class Xoshiro128ss:
                 return r % n
 
     def shuffle(self, items: list) -> None:
-        """Fisher-Yates, in place."""
+        """Fisher-Yates, in place: j = below(i + 1) for i = len-1 .. 1, with next32/below inlined
+        (same integer arithmetic, so the same stream as shuffle_reference)."""
+        s0, s1, s2, s3 = self.s
+        for i in range(len(items) - 1, 0, -1):
+            n = i + 1
+            limit = (4294967296 // n) * n
+            while True:
+                x = (s1 * 5) & M32
+                r = ((((x << 7) | (x >> 25)) & M32) * 9) & M32
+                t = (s1 << 9) & M32
+                s2 ^= s0
+                s3 ^= s1
+                s1 ^= s2
+                s0 ^= s3
+                s2 ^= t
+                s3 = ((s3 << 11) | (s3 >> 21)) & M32
+                if r < limit:
+                    break
+            j = r % n
+            items[i], items[j] = items[j], items[i]
+        self.s[:] = [s0, s1, s2, s3]
+
+    def shuffle_reference(self, items: list) -> None:
+        """Fisher-Yates, in place (the form shuffle() inlines)."""
         for i in range(len(items) - 1, 0, -1):
             j = self.below(i + 1)
             items[i], items[j] = items[j], items[i]

pytransdecoder-0.3.0/pytransdecoder/core/sequence.py

@@ -0,0 +1,32 @@
+"""
+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
+    """
+    if sequence.isascii():
+        return sequence.translate(_rc_table())[::-1]
+    return str(Seq(sequence).reverse_complement())
+
+
+_RC = None
+
+
+def _rc_table():
+    """Per-character complement of ASCII, taken from Biopython (whose reverse complement maps each
+    character independently), so translate + reverse equals Seq.reverse_complement."""
+    global _RC
+    if _RC is None:
+        _RC = str.maketrans({chr(o): str(Seq(chr(o)).reverse_complement()) for o in range(128)})
+    return _RC

{pytransdecoder-0.2.1 → pytransdecoder-0.3.0}/pytransdecoder/core/translator.py

@@ -78,6 +78,9 @@ class Translator:
         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]
+        # codon -> amino acid, filled from Biopython one codon at a time (Biopython translates
+        # each codon independently, so joining memoised codons gives the same protein)
+        self._codon_memo = {}
     
     def get_stop_codons(self) -> List[str]:
         """
@@ -108,15 +111,34 @@ class Translator:
     
     def translate(self, sequence: str, frame: int = 0) -> str:
         """
-        Translate nucleotide sequence to protein.
-        
+        Translate nucleotide sequence to protein (as Biopython's Seq.translate, to_stop=False;
+        a trailing partial codon is dropped).
+
         Args:
             sequence: DNA/RNA sequence
             frame: Reading frame offset (0, 1, or 2)
-        
+
         Returns:
             Protein sequence (stops are represented as *)
         """
+        seq = sequence[frame:].upper()
+        n = len(seq) - len(seq) % 3
+        memo = self._codon_memo
+        try:
+            return ''.join([memo[seq[i:i + 3]] for i in range(0, n, 3)])
+        except KeyError:
+            pass
+        for i in range(0, n, 3):
+            codon = seq[i:i + 3]
+            if codon not in memo:
+                try:
+                    memo[codon] = str(Seq(codon).translate(table=self.table_id, to_stop=False))
+                except Exception:
+                    return self._translate_reference(sequence, frame)
+        return ''.join([memo[seq[i:i + 3]] for i in range(0, n, 3)])
+
+    def _translate_reference(self, sequence: str, frame: int = 0) -> str:
+        """Whole-sequence Biopython translation (the form translate() reproduces codon by codon)."""
         # Adjust for frame
         seq = sequence[frame:].upper()