pytransdecoder 0.3.0__tar.gz → 0.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytransdecoder
-Version: 0.3.0
+Version: 0.4.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
@@ -81,6 +81,7 @@ This creates a directory `transcripts.fasta.transdecoder_dir/` with:
 -O, --output-dir PATH           Output directory
 --gene-trans-map PATH           Gene-to-transcript mapping file
 --complete-orfs-only            Only output complete ORFs
+--cpu INT                       Worker processes (default: 1); the output does not depend on it
 -v, --verbose                   Verbose output
 ```
 
@@ -179,8 +180,9 @@ 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
+--cpu INT                         Worker processes for scoring candidate and decoy ORFs, and in
+                                  pyTransdecoder also for LongOrfs (default: 1); the output does
+                                  not depend on it
 -G, --genetic-code TEXT           Genetic code (default: Standard)
 -v, --verbose                     Verbose output
 ```

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

@@ -60,6 +60,7 @@ This creates a directory `transcripts.fasta.transdecoder_dir/` with:
 -O, --output-dir PATH           Output directory
 --gene-trans-map PATH           Gene-to-transcript mapping file
 --complete-orfs-only            Only output complete ORFs
+--cpu INT                       Worker processes (default: 1); the output does not depend on it
 -v, --verbose                   Verbose output
 ```
 
@@ -158,8 +159,9 @@ 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
+--cpu INT                         Worker processes for scoring candidate and decoy ORFs, and in
+                                  pyTransdecoder also for LongOrfs (default: 1); the output does
+                                  not depend on it
 -G, --genetic-code TEXT           Genetic code (default: Standard)
 -v, --verbose                     Verbose output
 ```

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytransdecoder"
-version = "0.3.0"
+version = "0.4.0"
 description = "TransDecoder, the original Perl version ported to Python by AI/LLMs with new features integrated"
 readme = "README.md"
 requires-python = ">=3.8"

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

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

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

@@ -80,6 +80,10 @@ Example:
         help='Show version and exit'
     )
     
+    parser.add_argument('--cpu', type=int, default=1, dest='cpu',
+                        help="Worker processes for ORF extraction; the output does not depend on it "
+                             "(default: %(default)s)")
+
     parser.set_defaults(func=longorfs_cmd)
     return parser
 
@@ -107,8 +111,8 @@ def _add_selection_args(parser):
     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)")
+                        help="Worker processes for scoring candidate and decoy ORFs (pyTransdecoder: also for "
+                             "extracting 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 "
@@ -279,7 +283,8 @@ def longorfs_cmd(args):
             output_dir=args.output_dir,
             gene_trans_map_file=args.gene_trans_map,
             complete_orfs_only=args.complete_orfs_only,
-            verbose=args.verbose
+            verbose=args.verbose,
+            cpu=args.cpu
         )
     except Exception as e:
         print(f"Error: {e}", file=sys.stderr)
@@ -496,7 +501,8 @@ def pipeline_cmd(args):
             output_dir=args.output_dir,
             gene_trans_map_file=args.gene_trans_map,
             complete_orfs_only=args.complete_orfs_only,
-            verbose=args.verbose
+            verbose=args.verbose,
+            cpu=args.cpu
         )
     except Exception as e:
         print(f"Error during LongOrfs phase: {e}", file=sys.stderr)

{pytransdecoder-0.3.0 → pytransdecoder-0.4.0}/pytransdecoder/core/writers.py

@@ -56,14 +56,14 @@ class FastaWriter:
             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')
+        self.file.write(fasta_entry(header, sequence, wrap))
+
+
+def fasta_entry(header: str, sequence: str, wrap: int = 60) -> str:
+    """One FASTA record as text: header line (a '>' is added if missing), then the sequence
+    in lines of `wrap` characters (0 = one line)."""
+    if not header.startswith('>'):
+        header = '>' + header
+    if wrap > 0:
+        return header + '\n' + ''.join(sequence[i:i + wrap] + '\n' for i in range(0, len(sequence), wrap))
+    return header + '\n' + sequence + '\n'

pytransdecoder-0.4.0/pytransdecoder/longorfs.py

@@ -0,0 +1,247 @@
+"""
+TransDecoder.LongOrfs - Extract long ORFs from transcript sequences
+
+Phase 1 of TransDecoder pipeline.
+"""
+
+import sys
+from pathlib import Path
+from typing import Optional, Dict
+from .core.fasta import read_fasta
+from tqdm import tqdm
+
+from .core.orf_finder import ORFFinder
+from .core.writers import fasta_entry
+from .core.base_freqs import write_base_frequencies
+
+# Minimum ORF length (aa). Predict's decoy q-values (stratified by ORF length) decide how much coding
+# evidence short ORFs need.
+DEFAULT_MIN_PROTEIN_LENGTH = 50
+
+
+def run_longorfs(
+    transcripts_file: Path,
+    min_protein_length: int = DEFAULT_MIN_PROTEIN_LENGTH,
+    genetic_code: str = "universal",
+    strand_specific: bool = False,
+    output_dir: Optional[Path] = None,
+    gene_trans_map_file: Optional[Path] = None,
+    complete_orfs_only: bool = False,
+    verbose: bool = False,
+    cpu: int = 1
+):
+    """
+    Extract long ORFs from transcripts (Phase 1).
+    
+    Args:
+        transcripts_file: Input FASTA file
+        min_protein_length: Minimum protein length in amino acids
+        genetic_code: Genetic code name
+        strand_specific: Only analyze top strand
+        output_dir: Output directory
+        gene_trans_map_file: Gene to transcript mapping file
+        complete_orfs_only: Only output complete ORFs
+        verbose: Verbose output
+        cpu: Worker processes for ORF extraction (output does not depend on it)
+    """
+    
+    # Set up output directory
+    if output_dir is None:
+        output_dir = Path.cwd()
+    output_dir = Path(output_dir)
+    
+    # Create transdecoder_dir
+    workdir = output_dir / f"{transcripts_file.name}.transdecoder_dir"
+    workdir.mkdir(parents=True, exist_ok=True)
+    
+    if verbose:
+        print(f"Output directory: {workdir}", file=sys.stderr)
+    
+    # Load gene-transcript mapping if provided
+    gene_trans_map = {}
+    if gene_trans_map_file:
+        with open(gene_trans_map_file) as f:
+            for line in f:
+                parts = line.strip().split('\t')
+                if len(parts) >= 2:
+                    gene_id, trans_id = parts[0], parts[1]
+                    gene_trans_map[trans_id] = gene_id
+    
+    # LongOrfs settings, for Predict's decoy ORFs (same finder settings on shuffled transcripts)
+    import json
+    with open(workdir / "longorfs.params.json", "w") as fh:
+        json.dump({"min_protein_length": min_protein_length, "genetic_code": genetic_code,
+                   "strand_specific": bool(strand_specific),
+                   "complete_orfs_only": bool(complete_orfs_only)}, fh, indent=1)
+
+    # Output files
+    prefix = workdir / "longest_orfs"
+    cds_file = prefix.with_suffix('.cds')
+    gff3_file = prefix.with_suffix('.gff3')
+    pep_file = prefix.with_suffix('.pep')
+
+    finder_args = dict(
+        min_protein_length=min_protein_length,
+        allow_5prime_partial=not complete_orfs_only,
+        allow_3prime_partial=not complete_orfs_only,
+        forward_strand=True,
+        reverse_strand=not strand_specific,
+        genetic_code=genetic_code,
+        complete_orfs_only=complete_orfs_only
+    )
+    settings = (finder_args, gene_trans_map, genetic_code, strand_specific)
+    cpu = max(1, int(cpu))
+
+    if verbose:
+        print("\n\n- extracting ORFs from transcripts.\n", file=sys.stderr)
+
+    if cpu == 1:
+        # one pass over the input, streamed (a counting pass for the progress bar only when verbose)
+        total_transcripts = sum(1 for _ in read_fasta(transcripts_file)) if verbose else None
+        chunks = _batches(((r.id, str(r.seq)) for r in read_fasta(transcripts_file)), SERIAL_BATCH)
+    else:
+        records = [(r.id, str(r.seq)) for r in read_fasta(transcripts_file)]
+        total_transcripts = len(records)
+        # Model IDs are <acc>.p1, .p2, ... numbered within a transcript; IDs of different accessions
+        # never coincide (the last '.p' of an ID starts its numeric suffix), so chunks can be numbered
+        # independently. A repeated accession continues the numbering of its earlier copy, so inputs
+        # with repeated accessions are processed in one chunk.
+        n_repeated = total_transcripts - len({acc for acc, _ in records})
+        if n_repeated:
+            print(f"Warning: {n_repeated} repeated transcript accessions; extracting ORFs in a single "
+                  f"process", file=sys.stderr)
+            chunks, cpu = [records], 1
+        else:
+            chunks = _chunks_by_size(records, cpu * 16)
+        del records
+
+    if verbose:
+        print(f"-total transcripts to examine: {total_transcripts}\n", file=sys.stderr)
+
+    base_counts = {base: 0 for base in 'ACGT'}
+    progress = tqdm(total=total_transcripts, desc="Processing transcripts", disable=not verbose,
+                    file=sys.stderr)
+    with open(gff3_file, 'w') as gff_fh, open(cds_file, 'w') as cds_fh, open(pep_file, 'w') as pep_fh:
+        gff_fh.write("##gff-version 3\n")
+        for n, counts, gff, cds, pep in _map_chunks(chunks, settings, cpu):
+            for base in 'ACGT':
+                base_counts[base] += counts[base]
+            gff_fh.write(gff)
+            cds_fh.write(cds)
+            pep_fh.write(pep)
+            progress.update(n)
+    progress.close()
+
+    # Base frequencies (the per-chunk counts are integers, so their sum is exact)
+    write_base_frequencies(base_counts, str(workdir / "base_freqs.dat"))
+
+    # Print summary
+    if verbose:
+        print(f"\n\n#################################", file=sys.stderr)
+        print(f"### Done preparing long ORFs  ###", file=sys.stderr)
+        print(f"##################################", file=sys.stderr)
+        print(f"\n\tUse file: {pep_file}  for Pfam and/or BlastP searches to enable homology-based coding region identification.\n\n", file=sys.stderr)
+        print(f"\tThen, run TransDecoder.Predict\n\n", file=sys.stderr)
+
+
+# -- ORF extraction of chunks of transcripts (in this process or in worker processes) -------------
+
+_SETTINGS = None
+_SEEN_PROT_IDS: set = set()
+SERIAL_BATCH = 2000  # transcripts per batch when streaming with --cpu 1
+
+
+def _init_worker(settings):
+    """Settings, and one set of issued model IDs per process for the whole run."""
+    global _SETTINGS, _SEEN_PROT_IDS
+    _SETTINGS = settings
+    _SEEN_PROT_IDS = set()
+
+
+def _extract_chunk(records):
+    """(n transcripts, base counts, gff3 text, cds text, pep text) of an iterable of (acc, sequence),
+    numbering model IDs as the original single loop does."""
+    finder_args, gene_trans_map, genetic_code, strand_specific = _SETTINGS
+    orf_finder = ORFFinder(**finder_args)
+    complement = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}
+    counts = {base: 0 for base in 'ACGT'}
+    gff, cds, pep = [], [], []
+    seen_prot_ids = _SEEN_PROT_IDS
+    n = 0
+    for acc, sequence in records:
+        n += 1
+        # base counts, as core.base_freqs.compute_base_counts
+        useq = sequence.upper()
+        for base in 'ACGT':
+            k = useq.count(base)
+            counts[base] += k
+            if not strand_specific:
+                counts[complement[base]] += k
+
+        for orf in orf_finder.find_all_orfs(sequence, acc):
+            # Generate unique model ID
+            pcounter = 1
+            model_id = f"{acc}.p{pcounter}"
+            while model_id in seen_prot_ids:
+                pcounter += 1
+                model_id = f"{acc}.p{pcounter}"
+            seen_prot_ids.add(model_id)
+
+            gene_id = gene_trans_map.get(acc, f"GENE.{acc}")
+            gene_id = f"{gene_id}~~{model_id}"
+
+            orf.model_id = model_id
+            orf.gene_id = gene_id
+            orf.description = f"ORF type:{orf.orf_type} ({orf.strand})"
+
+            gff.append(orf.to_gff3() + "\n")
+            cds.append(fasta_entry(
+                f">{model_id} type:{orf.orf_type} {acc}:{orf.start}-{orf.end}({orf.strand})", orf.sequence))
+            pep.append(fasta_entry(
+                f">{model_id} type:{orf.orf_type} gc:{genetic_code} {acc}:{orf.start}-{orf.end}({orf.strand})",
+                orf.protein))
+    return n, counts, "".join(gff), "".join(cds), "".join(pep)
+
+
+def _batches(it, size):
+    """Consecutive lists of up to `size` items of an iterator."""
+    from itertools import islice
+    while True:
+        b = list(islice(it, size))
+        if not b:
+            return
+        yield b
+
+
+def _chunks_by_size(records, n_chunks):
+    """Consecutive chunks of roughly equal total sequence length (order preserved)."""
+    total = sum(len(s) for _, s in records) or 1
+    target = total / n_chunks
+    chunks, cur, acc = [], [], 0
+    for rec in records:
+        cur.append(rec)
+        acc += len(rec[1])
+        if acc >= target:
+            chunks.append(cur)
+            cur, acc = [], 0
+    if cur:
+        chunks.append(cur)
+    return chunks
+
+
+def _map_chunks(chunks, settings, cpu):
+    """_extract_chunk results in chunk order."""
+    if cpu <= 1:
+        _init_worker(settings)
+        try:
+            for c in chunks:
+                yield _extract_chunk(c)
+        finally:
+            _init_worker(None)  # release the ID set
+        return
+    from concurrent.futures import ProcessPoolExecutor
+    import multiprocessing as mp
+    ctx = mp.get_context("fork") if "fork" in mp.get_all_start_methods() else None
+    with ProcessPoolExecutor(max_workers=cpu, mp_context=ctx, initializer=_init_worker,
+                             initargs=(settings,)) as ex:
+        yield from ex.map(_extract_chunk, chunks)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytransdecoder
-Version: 0.3.0
+Version: 0.4.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
@@ -81,6 +81,7 @@ This creates a directory `transcripts.fasta.transdecoder_dir/` with:
 -O, --output-dir PATH           Output directory
 --gene-trans-map PATH           Gene-to-transcript mapping file
 --complete-orfs-only            Only output complete ORFs
+--cpu INT                       Worker processes (default: 1); the output does not depend on it
 -v, --verbose                   Verbose output
 ```
 
@@ -179,8 +180,9 @@ 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
+--cpu INT                         Worker processes for scoring candidate and decoy ORFs, and in
+                                  pyTransdecoder also for LongOrfs (default: 1); the output does
+                                  not depend on it
 -G, --genetic-code TEXT           Genetic code (default: Standard)
 -v, --verbose                     Verbose output
 ```

{pytransdecoder-0.3.0 → pytransdecoder-0.4.0}/pytransdecoder.egg-info/SOURCES.txt

@@ -72,6 +72,7 @@ tests/test_decoys.py
 tests/test_fasta.py
 tests/test_genome_bed.py
 tests/test_homology_starts.py
+tests/test_longorfs_parallel.py
 tests/test_markov_fast.py
 tests/test_parallel.py
 tests/test_qvalue_modes.py

pytransdecoder-0.4.0/tests/test_longorfs_parallel.py

@@ -0,0 +1,85 @@
+"""LongOrfs --cpu: output files identical to the single-process run."""
+
+import random
+from pathlib import Path
+
+import pytest
+
+from pytransdecoder.longorfs import run_longorfs
+
+FILES = ["longest_orfs.gff3", "longest_orfs.cds", "longest_orfs.pep", "base_freqs.dat",
+         "longorfs.params.json"]
+
+
+def _random_fasta(path: Path, ids, seed=7):
+    rng = random.Random(seed)
+    with open(path, "w") as fh:
+        for i, acc in enumerate(ids):
+            n = rng.randint(100, 3000)
+            # coding-like stretches (no in-frame stop) mixed with random sequence, some IUPAC / lowercase
+            seq = "".join(rng.choice("ACGT") for _ in range(n))
+            if i % 3 == 0:
+                body = "".join(rng.choice(["GCT", "AAA", "CTG", "GAG", "TCC", "ATG"]) for _ in range(150))
+                seq = seq[:50] + "ATG" + body + "TAA" + seq[50:]
+            if i % 5 == 0:
+                seq = seq[:30] + "N" + seq[31:]
+            if i % 7 == 0:
+                seq = seq.lower()
+            fh.write(f">{acc} desc {i}\n")
+            for k in range(0, len(seq), 70):
+                fh.write(seq[k:k + 70] + "\n")
+
+
+def _run(tmp_path, name, fasta, cpu, **kw):
+    out = tmp_path / name
+    out.mkdir()
+    run_longorfs(fasta, output_dir=out, cpu=cpu, **kw)
+    d = out / f"{fasta.name}.transdecoder_dir"
+    return {f: (d / f).read_bytes() for f in FILES}
+
+
+@pytest.mark.parametrize("strand_specific", [False, True])
+@pytest.mark.parametrize("genetic_code", ["universal", "Tetrahymena"])
+def test_cpu_parity(tmp_path, strand_specific, genetic_code):
+    ids = [f"tx{i}" for i in range(120)] + ["A", "A.p1", "A.p1.p", "B.p2"]  # IDs that look like model IDs
+    fasta = tmp_path / "t.fa"
+    _random_fasta(fasta, ids)
+    kw = dict(strand_specific=strand_specific, genetic_code=genetic_code, min_protein_length=30)
+    one = _run(tmp_path, "c1", fasta, 1, **kw)
+    assert one["longest_orfs.pep"].count(b">") > 50
+    import pytransdecoder.longorfs as lo
+    lo.SERIAL_BATCH, keep = 7, lo.SERIAL_BATCH
+    try:
+        assert _run(tmp_path, "c1b", fasta, 1, **kw) == one
+    finally:
+        lo.SERIAL_BATCH = keep
+    for cpu in (2, 3, 8):
+        assert _run(tmp_path, f"c{cpu}", fasta, cpu, **kw) == one
+
+
+@pytest.mark.parametrize("batch", [2000, 3])
+def test_repeated_accessions(tmp_path, monkeypatch, batch):
+    """A repeated accession continues the .pN numbering of its earlier copy, at any --cpu and
+    across the batches of the streamed single-process run."""
+    import pytransdecoder.longorfs as lo
+    monkeypatch.setattr(lo, "SERIAL_BATCH", batch)
+    ids = [f"tx{i}" for i in range(40)] + ["tx3", "tx0", "tx3"]
+    fasta = tmp_path / "t.fa"
+    _random_fasta(fasta, ids)
+    one = _run(tmp_path, "c1", fasta, 1, min_protein_length=30)
+    assert _run(tmp_path, "c4", fasta, 4, min_protein_length=30) == one
+    pep = one["longest_orfs.pep"].decode()
+    tx3 = [l.split()[0] for l in pep.splitlines() if l.startswith(">tx3.p")]
+    assert len(tx3) == len(set(tx3)) > 1
+
+
+def test_gene_trans_map_and_complete_only(tmp_path):
+    ids = [f"tx{i}" for i in range(60)]
+    fasta = tmp_path / "t.fa"
+    _random_fasta(fasta, ids)
+    gtm = tmp_path / "gtm.tsv"
+    gtm.write_text("".join(f"gene{i // 2}\ttx{i}\n" for i in range(0, 60, 3)))
+    for kw in (dict(gene_trans_map_file=gtm), dict(complete_orfs_only=True)):
+        kw["min_protein_length"] = 30
+        one = _run(tmp_path, f"c1_{len(kw)}_{'g' if 'gene_trans_map_file' in kw else 'c'}", fasta, 1, **kw)
+        assert _run(tmp_path, f"c3_{'g' if 'gene_trans_map_file' in kw else 'c'}", fasta, 3, **kw) == one

pytransdecoder-0.3.0/pytransdecoder/longorfs.py

@@ -1,180 +0,0 @@
-"""
-TransDecoder.LongOrfs - Extract long ORFs from transcript sequences
-
-Phase 1 of TransDecoder pipeline.
-"""
-
-import sys
-from pathlib import Path
-from typing import Optional, Dict
-from collections import defaultdict
-from .core.fasta import read_fasta
-from tqdm import tqdm
-
-from .core.orf_finder import ORFFinder
-from .core.models import ORF
-from .core.writers import GFF3Writer, FastaWriter
-from .core.base_freqs import compute_base_counts, write_base_frequencies
-
-# Minimum ORF length (aa). Predict's decoy q-values (stratified by ORF length) decide how much coding
-# evidence short ORFs need.
-DEFAULT_MIN_PROTEIN_LENGTH = 50
-
-
-def run_longorfs(
-    transcripts_file: Path,
-    min_protein_length: int = DEFAULT_MIN_PROTEIN_LENGTH,
-    genetic_code: str = "universal",
-    strand_specific: bool = False,
-    output_dir: Optional[Path] = None,
-    gene_trans_map_file: Optional[Path] = None,
-    complete_orfs_only: bool = False,
-    verbose: bool = False
-):
-    """
-    Extract long ORFs from transcripts (Phase 1).
-    
-    Args:
-        transcripts_file: Input FASTA file
-        min_protein_length: Minimum protein length in amino acids
-        genetic_code: Genetic code name
-        strand_specific: Only analyze top strand
-        output_dir: Output directory
-        gene_trans_map_file: Gene to transcript mapping file
-        complete_orfs_only: Only output complete ORFs
-        verbose: Verbose output
-    """
-    
-    # Set up output directory
-    if output_dir is None:
-        output_dir = Path.cwd()
-    output_dir = Path(output_dir)
-    
-    # Create transdecoder_dir
-    workdir = output_dir / f"{transcripts_file.name}.transdecoder_dir"
-    workdir.mkdir(parents=True, exist_ok=True)
-    
-    if verbose:
-        print(f"Output directory: {workdir}", file=sys.stderr)
-    
-    # Load gene-transcript mapping if provided
-    gene_trans_map = {}
-    if gene_trans_map_file:
-        with open(gene_trans_map_file) as f:
-            for line in f:
-                parts = line.strip().split('\t')
-                if len(parts) >= 2:
-                    gene_id, trans_id = parts[0], parts[1]
-                    gene_trans_map[trans_id] = gene_id
-    
-    # LongOrfs settings, for Predict's decoy ORFs (same finder settings on shuffled transcripts)
-    import json
-    with open(workdir / "longorfs.params.json", "w") as fh:
-        json.dump({"min_protein_length": min_protein_length, "genetic_code": genetic_code,
-                   "strand_specific": bool(strand_specific),
-                   "complete_orfs_only": bool(complete_orfs_only)}, fh, indent=1)
-
-    # Step 1: Compute base frequencies
-    if verbose:
-        print("\n\n-first extracting base frequencies, we'll need them later.\n", file=sys.stderr)
-    
-    base_freqs_file = workdir / "base_freqs.dat"
-    base_counts = compute_base_counts(str(transcripts_file), strand_specific)
-    write_base_frequencies(base_counts, str(base_freqs_file))
-    
-    # Step 2: Extract ORFs
-    if verbose:
-        print("\n\n- extracting ORFs from transcripts.\n", file=sys.stderr)
-    
-    # Initialize ORF finder
-    orf_finder = ORFFinder(
-        min_protein_length=min_protein_length,
-        allow_5prime_partial=not complete_orfs_only,
-        allow_3prime_partial=not complete_orfs_only,
-        forward_strand=True,
-        reverse_strand=not strand_specific,
-        genetic_code=genetic_code,
-        complete_orfs_only=complete_orfs_only
-    )
-    
-    # Output files
-    prefix = workdir / "longest_orfs"
-    cds_file = prefix.with_suffix('.cds')
-    gff3_file = prefix.with_suffix('.gff3')
-    pep_file = prefix.with_suffix('.pep')
-    
-    # Count total transcripts for progress bar
-    total_transcripts = sum(1 for _ in read_fasta(transcripts_file))
-    
-    if verbose:
-        print(f"-total transcripts to examine: {total_transcripts}\n", file=sys.stderr)
-    
-    # Process transcripts
-    model_counter = 0
-    trans_counter = 0
-    seen_prot_ids = set()
-    
-    with GFF3Writer(gff3_file) as gff_writer, \
-         FastaWriter(cds_file) as cds_writer, \
-         FastaWriter(pep_file) as pep_writer:
-        
-        progress = tqdm(
-            read_fasta(transcripts_file),
-            total=total_transcripts,
-            desc="Processing transcripts",
-            disable=not verbose,
-            file=sys.stderr
-        )
-        
-        for record in progress:
-            trans_counter += 1
-            
-            acc = record.id
-            sequence = str(record.seq)
-            
-            # Find all ORFs
-            orfs = orf_finder.find_all_orfs(sequence, acc)
-            
-            # Process each ORF
-            for orf in orfs:
-                model_counter += 1
-                
-                # Generate unique model ID
-                pcounter = 1
-                model_id = f"{acc}.p{pcounter}"
-                while model_id in seen_prot_ids:
-                    pcounter += 1
-                    model_id = f"{acc}.p{pcounter}"
-                seen_prot_ids.add(model_id)
-                
-                # Generate gene ID
-                if acc in gene_trans_map:
-                    gene_id = gene_trans_map[acc]
-                else:
-                    gene_id = f"GENE.{acc}"
-                
-                gene_id = f"{gene_id}~~{model_id}"
-                
-                # Update ORF with IDs
-                orf.model_id = model_id
-                orf.gene_id = gene_id
-                orf.description = f"ORF type:{orf.orf_type} ({orf.strand})"
-                
-                # Write outputs
-                gff_writer.write_orf(orf)
-                
-                # Write CDS
-                cds_header = f">{model_id} type:{orf.orf_type} {acc}:{orf.start}-{orf.end}({orf.strand})"
-                cds_writer.write_sequence(cds_header, orf.sequence)
-                
-                # Write protein
-                pep_header = f">{model_id} type:{orf.orf_type} gc:{genetic_code} {acc}:{orf.start}-{orf.end}({orf.strand})"
-                pep_writer.write_sequence(pep_header, orf.protein)
-    
-    # Print summary
-    if verbose:
-        print(f"\n\n#################################", file=sys.stderr)
-        print(f"### Done preparing long ORFs  ###", file=sys.stderr)
-        print(f"##################################", file=sys.stderr)
-        print(f"\n\tUse file: {pep_file}  for Pfam and/or BlastP searches to enable homology-based coding region identification.\n\n", file=sys.stderr)
-        print(f"\tThen, run TransDecoder.Predict\n\n", file=sys.stderr)