mafutils 0.1.1__py3-none-any.whl

mafutils/fetch.py

@@ -0,0 +1,1311 @@
+#############################################################################
+# Given a MAF file, its index generated by `mafutils index`, and a bed file,
+# this script will output the alignment blocks from the MAF file that overlap
+# the regions specified in the bed file. The output will be trimmed to only
+# include the exact portion of the alignment block that overlaps the bed region.
+#
+# Gregg Thomas, April 2025
+#############################################################################
+
+"""
+mafutils fetch
+
+This script fetches alignment blocks from a MAF (Multiple Alignment Format) file
+that overlap regions specified in a BED file. It works in two modes:
+
+    Block mode:
+        - Uses a block-level index
+        - Extracts blocks overlapping each [start, end) BED interval
+        - Trims blocks to exactly match the specified region
+        - Output files are named by region ID or scaffold.counter (e.g., chr1.1.maf)
+
+    Scaffold mode:  
+        - Uses a scaffold-level index
+        - Treats the BED file as a list of scaffold names (only column 1 is required)
+        - Extracts all alignment blocks for each scaffold from the MAF
+        - Output files are named by scaffold (e.g., chr1.maf, chrZ.maf)
+
+Parallelization:
+    - Block mode is parallelized by region
+    - Scaffold mode is parallelized by scaffold
+    - The number of processes can be controlled with --processes
+
+Required input:
+    - A MAF file (.maf or .maf.gz)
+    - A MAF index file (from `mafutils index`)
+    - A BED file
+
+Optional arguments:
+    --outdir, -o         Output directory (default: current directory)
+    --processes, -p      Number of parallel processes (default: 1)
+    --mode, -m           Mode: 'block' or 'scaffold' (default: 'block')
+
+Compression:
+    - Gzipped MAF files (.maf.gz) are supported, provided the index is built
+    from the compressed file using gzip.open()
+
+Usage:
+    python -m mafutils fetch <maf_file> <index_file> <bed_file> [--outdir DIR] [--processes N] [--mode block|scaffold]
+
+Examples:
+    Block mode with 4 threads:
+        python -m mafutils fetch alignment.maf.gz index.idx regions.bed --processes 4
+
+    Scaffold mode with default output:
+        python -m mafutils fetch alignment.maf.gz index.idx scaffolds.bed --mode scaffold
+"""
+
+import sys
+import os
+import re
+import atexit
+import gzip
+import logging
+import bisect
+import time
+from enum import Enum
+from types import SimpleNamespace
+from typing import Annotated
+from concurrent.futures import FIRST_COMPLETED, ProcessPoolExecutor, wait
+from collections import defaultdict, OrderedDict
+
+import typer
+
+from mafutils.lib import common as COMMON
+from mafutils.lib import loginit as LOGINIT
+
+#############################################################################
+
+MAX_NO_OVERLAP_REGIONS_DEFAULT = 10000
+MAX_NO_OVERLAP_FRACTION_DEFAULT = 0.10
+WORKER_BLOCK_CACHE_MAX = 2048
+
+WORKER_HEADER = None
+WORKER_MAF_FILE = None
+WORKER_MAF_COMPRESSION = None
+WORKER_INDEX = None
+WORKER_OUTPUT = None
+WORKER_SINGLE_OUTPUT = None
+WORKER_AS_FASTA = None
+WORKER_FASTA_HEADER = None
+WORKER_EXPECTED_SPECIES = None
+WORKER_FASTA_DEDUPE = None
+WORKER_VERBOSE = None
+WORKER_PROFILE = None
+WORKER_MAF_FP = None
+WORKER_BLOCK_CACHE = None
+
+#############################################################################
+
+class BasenameMode(str, Enum):
+    id = "id"
+    coords = "coords"
+    count = "count"
+
+
+class FastaHeaderMode(str, Enum):
+    species_coords_id = "species-coords-id"
+    species_coords = "species-coords"
+    species_only = "species-only"
+
+
+class FastaDedupeMode(str, Enum):
+    none = "none"
+    most_seq = "most-seq"
+
+
+class FetchMode(str, Enum):
+    block = "block"
+    scaffold = "scaffold"
+
+#############################################################################
+
+def parseExpectedSpecies(args):
+    expected = []
+    seen = set()
+
+    if args.expected_species:
+        for sp in args.expected_species.split(","):
+            sp = sp.strip()
+            if sp and sp not in seen:
+                expected.append(sp)
+                seen.add(sp)
+
+    if args.expected_species_file:
+        with open(args.expected_species_file, "r", encoding="utf-8") as fp:
+            for line in fp:
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                if line not in seen:
+                    expected.append(line)
+                    seen.add(line)
+
+    return expected
+
+#############################################################################
+
+def pick_chunk_size(num_regions, num_procs, min_size=100):
+    n_batches = max(num_procs * 2, 1)
+    batch_size = max(min_size, (num_regions + n_batches - 1) // n_batches)
+    return batch_size
+
+def chunker(seq, size=1000):
+    for pos in range(0, len(seq), size):
+        yield seq[pos:pos+size]
+
+#############################################################################
+
+def initBatchWorker(
+    header,
+    maf_file,
+    maf_compression,
+    index,
+    output,
+    single_output,
+    as_fasta,
+    fasta_header,
+    expected_species,
+    fasta_dedupe,
+    verbose,
+    profile,
+):
+    global WORKER_HEADER
+    global WORKER_MAF_FILE
+    global WORKER_MAF_COMPRESSION
+    global WORKER_INDEX
+    global WORKER_OUTPUT
+    global WORKER_SINGLE_OUTPUT
+    global WORKER_AS_FASTA
+    global WORKER_FASTA_HEADER
+    global WORKER_EXPECTED_SPECIES
+    global WORKER_FASTA_DEDUPE
+    global WORKER_VERBOSE
+    global WORKER_PROFILE
+    global WORKER_MAF_FP
+    global WORKER_BLOCK_CACHE
+
+    WORKER_HEADER = header
+    WORKER_MAF_FILE = maf_file
+    WORKER_MAF_COMPRESSION = maf_compression
+    WORKER_INDEX = index
+    WORKER_OUTPUT = output
+    WORKER_SINGLE_OUTPUT = single_output
+    WORKER_AS_FASTA = as_fasta
+    WORKER_FASTA_HEADER = fasta_header
+    WORKER_EXPECTED_SPECIES = expected_species
+    WORKER_FASTA_DEDUPE = fasta_dedupe
+    WORKER_VERBOSE = verbose
+    WORKER_PROFILE = profile
+    WORKER_BLOCK_CACHE = OrderedDict()
+
+    opener = gzip.open if maf_compression == "gz" else open
+    WORKER_MAF_FP = opener(maf_file, "rb")
+    atexit.register(closeBatchWorker)
+
+#############################################################################
+
+def closeBatchWorker():
+    global WORKER_MAF_FP
+    if WORKER_MAF_FP is not None:
+        WORKER_MAF_FP.close()
+        WORKER_MAF_FP = None
+
+#############################################################################
+
+def parseIndex(index_file, LOG, mode="block"):
+    """
+    Parses either a block-level or region-level index file.
+
+    For block mode:
+        Returns: { scaffold: [ { ref_start, seq_length, offset_start, offset_end }, ... ] }
+
+    For scaffold mode:
+        Returns: { scaffold: (byte_start, byte_end) } — one entry per scaffold
+    """
+    index = {}
+
+    with open(index_file, "r") as f:
+        for line in f:
+            if line.startswith("#") or not line.strip():
+                continue
+            fields = line.strip().split("\t")
+
+            if mode == "block":
+                if len(fields) < 7:
+                    LOG.warning(f"Skipping malformed index line: {line.strip()}", file=sys.stderr)
+                    continue
+                scaffold = fields[0]
+                try:
+                    ref_start = int(fields[1])
+                    ref_length = int(fields[2])
+                    aln_length = int(fields[3])
+                    offset_start = int(fields[6])
+                    offset_end = int(fields[7])
+                except ValueError:
+                    continue
+                entry = {
+                    "ref_start": ref_start,
+                    "ref_length": ref_length,
+                    "aln_length": aln_length,
+                    "offset_start": offset_start,
+                    "offset_end": offset_end
+                }
+                index.setdefault(scaffold, []).append(entry)
+
+            elif mode == "scaffold":
+                if len(fields) != 3:
+                    LOG.warning(f"Skipping malformed index line: {line.strip()}", file=sys.stderr)
+                    continue
+                scaffold = fields[0]
+                try:
+                    offset_start = int(fields[1])
+                    offset_end = int(fields[2])
+                except ValueError:
+                    continue
+                index[scaffold] = (offset_start, offset_end)
+
+    # Sort block entries per scaffold
+    if mode == "block":
+        for scaffold in index:
+            index[scaffold].sort(key=lambda x: x["ref_start"])
+            index[scaffold] = {
+                "entries": index[scaffold],
+                "starts": [entry["ref_start"] for entry in index[scaffold]],
+            }
+
+    return index
+
+#############################################################################
+
+def parseBed(bed_file, LOG, mode="block"):
+    """
+    Parses the BED file into a list of region dictionaries.
+
+    In "block" mode: expects at least 3 columns (scaffold, start, end)
+    Each region has keys:
+        - scaffold (chromosome)
+        - start (integer, 0-based)
+        - end (integer, non-inclusive)
+        - basename (from column 4, if present; otherwise None)
+
+    In "scaffold" mode: accepts 1+ columns; only uses first column (scaffold)
+    """
+    regions = []
+    with open(bed_file, "r") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            fields = line.split()
+            if mode == "scaffold":
+                scaffold = fields[0]
+                region = {"scaffold": scaffold, "start": 0, "end": 0, "id": fields[3] if len(fields) >= 4 else None}
+                regions.append(region)
+            else:
+                # block mode: require at least 3 columns (scaffold/start/end)
+                try:
+                    scaffold = fields[0]
+                    start = int(fields[1])
+                    end = int(fields[2])
+                    region = {"scaffold": scaffold, "start": start, "end": end, "id": fields[3] if len(fields) >= 4 else None}
+                    regions.append(region)
+                except (IndexError, ValueError):
+                    LOG.warning(f"Skipping malformed BED line: {line}", file=sys.stderr)
+                    continue
+    return regions
+
+#############################################################################
+
+def getMAFHeader(maf_file, maf_compression):
+    """Return header lines (starting with ##) from the MAF file, skipping blank lines."""
+    headers = []
+    if maf_compression == "gz":
+        opener = gzip.open
+        mode = "rt"
+    else:
+        opener = open
+        mode = "rt"
+    with opener(maf_file, mode) as fp:
+        for line in fp:
+            line = line.strip()
+            if not line:  # Skip blank lines
+                continue
+            if line.startswith("##"):
+                headers.append(line)
+            else:
+                break
+    # print(f"Found {len(headers)} header lines in MAF file.")
+    # print(f"Header lines:\n{headers}")
+    # sys.exit();
+    return "\n".join(headers) + "\n"
+
+#############################################################################
+
+def speciesFromSrc(src):
+    return src.split(".", 1)[0] if "." in src else src
+
+#############################################################################
+
+def appendWarning(warning_state, message):
+    if warning_state is None:
+        return
+
+    warning_state["count"] += 1
+    if warning_state["messages"] is not None:
+        warning_state["messages"].append(message)
+
+
+def getFillString(fill_cache, fill_char, block_len):
+    cache_key = (fill_char, block_len)
+    if cache_key not in fill_cache:
+        fill_cache[cache_key] = fill_char * block_len
+    return fill_cache[cache_key]
+
+
+def getCachedBlockText(maf_fp, entry):
+    cache_key = (entry["offset_start"], entry["offset_end"])
+    if cache_key in WORKER_BLOCK_CACHE:
+        WORKER_BLOCK_CACHE.move_to_end(cache_key)
+        return WORKER_BLOCK_CACHE[cache_key]
+
+    maf_fp.seek(entry["offset_start"])
+    block_bytes = maf_fp.read(entry["offset_end"] - entry["offset_start"])
+    block_text = block_bytes.decode("utf-8", errors="replace")
+    WORKER_BLOCK_CACHE[cache_key] = block_text
+    if len(WORKER_BLOCK_CACHE) > WORKER_BLOCK_CACHE_MAX:
+        WORKER_BLOCK_CACHE.popitem(last=False)
+    return block_text
+
+
+def initProfileState():
+    return {
+        "regions": 0,
+        "candidate_entries": 0,
+        "overlap_blocks": 0,
+        "time_batch_total": 0.0,
+        "time_region_total": 0.0,
+        "time_index_scan": 0.0,
+        "time_read_decode": 0.0,
+        "time_trim": 0.0,
+        "time_block_to_fasta": 0.0,
+        "time_fasta_stitch": 0.0,
+        "time_write_fasta": 0.0,
+    }
+
+
+def addProfile(profile_state, key, value):
+    if profile_state is not None:
+        profile_state[key] += value
+
+
+def mafBlockToFasta(block_text, region, dedupe_mode="none", use_species_keys=False):
+    """
+    Converts a (trimmed) MAF block to multi-FASTA format. 
+    Each FASTA header includes the species, chrom, strand, and the (possibly trimmed) coordinates.
+    Optionally, include region/scaffold in headers.
+    """
+    fasta_lines = defaultdict(dict)
+    lines = block_text.strip().splitlines()
+    block_len = 0
+
+    for line in lines:
+        if line.startswith("s "):
+            fields = line.split()
+            src = fields[1]  # species.chrom
+            species = speciesFromSrc(src)
+            #chrom = ".".join(src.split(".")[1:]) if "." in src else src
+            #sp = src.split(".")[0] if "." in src else src
+            start = int(fields[2])
+            size = int(fields[3])
+            strand = fields[4]
+            #srcSize = fields[5]
+            seq = fields[6]
+            block_len = len(seq)
+            key = species if use_species_keys else src
+            nongap = sum(1 for c in seq if c != "-")
+            
+            # Compute 1-based closed interval for clarity (as in FASTA tools)
+            if strand == "+":
+                end = start + size
+            else:
+                # For negative strand, coordinates can be reported as on "forward" chromosome (for clarity, as in MAF)
+                end = start + size
+
+            if key in fasta_lines and dedupe_mode == "most-seq":
+                if nongap > fasta_lines[key]["nongap"]:
+                    fasta_lines[key] = {'seq': seq, 'start': start, 'end': end, 'strand': strand, 'nongap': nongap}
+            elif key not in fasta_lines:
+                fasta_lines[key] = {'seq': seq, 'start': start, 'end': end, 'strand': strand, 'nongap': nongap}
+            elif dedupe_mode == "none":
+                # Preserve previous behavior when dedupe is off by keeping src keys unique.
+                # If duplicate src appears, keep first occurrence.
+                pass
+
+    for key in list(fasta_lines.keys()):
+        if "nongap" in fasta_lines[key]:
+            del fasta_lines[key]["nongap"]
+
+    return fasta_lines, block_len
+
+#############################################################################
+
+def writeFASTA(fasta_seqs, region, fasta_stream, BATCHLOG, fasta_header=False, verbose=False, warning_state=None):
+
+    fasta_output = {}
+    for sp, details in fasta_seqs.items():
+        if fasta_header == "species-only":
+            header = f">{speciesFromSrc(sp)}"
+        else:
+            if details['starts'] and details['ends']:
+                region_start = min(details['starts'])
+                region_end = max(details['ends'])
+            else:
+                region_start = region['start']
+                region_end = region['end']
+            strand = list(set(details['strands'])) if details['strands'] else ["."]
+            
+            if len(strand) == 1:
+                region_strand = strand[0]
+            else:
+                region_strand = "."
+                appendWarning(
+                    warning_state,
+                    f"Multiple strands found for species {sp} in region {region['scaffold']}:{region['start']}-{region['end']}. Using '.' in header.",
+                )
+
+            if fasta_header == "species-coords":
+                header = f">{sp}:{region_start}-{region_end}({region_strand})"
+            elif fasta_header == "species-coords-id":
+                if "id" in region and region["id"]:
+                    id_str = f"id:{region['id']}"
+                header = f">{sp}:{region_start}-{region_end}({region_strand}) {id_str}"
+
+        fasta_stream.write(f"{header}\n{''.join(details['seq'])}\n")
+
+#############################################################################
+
+def trimMafBlock(block_text, bed_start, bed_end, BATCHLOG, verbose=False, warning_state=None):
+    """
+    Trims a MAF block to exactly the portion overlapping [bed_start, bed_end)
+    on the reference sequence. Assumes the reference sequence is given in the
+    first "s" line after the header.
+
+    The MAF "s" line format:
+        s <src> <start> <size> <strand> <srcSize> <aligned_sequence>
+
+    Returns the trimmed block as a string, or None if no overlap occurs.
+    """
+
+    lines = block_text.splitlines()
+    if len(lines) < 2:
+        return None  # Invalid block
+    trimmed_lines = []
+    if lines[0].startswith("a"):
+        trimmed_lines.append(lines[0])
+    else:
+        trimmed_lines.append("a")
+    
+    ref_line_found = False
+    ref_col_start = None
+    ref_col_end = None
+    new_ref_start = None
+    new_ref_size = None
+    for line in lines[1:]:
+
+        fields = line.split()
+
+        if not fields or fields[0] != "s":
+            trimmed_lines.append(line)
+            continue
+
+        if not ref_line_found:
+            ref_line_found = True
+            try:
+                block_ref_start = int(fields[2])
+                block_ref_size = int(fields[3])
+            except ValueError:
+                BATCHLOG.error("Error parsing reference coordinates in MAF block.")
+            ref_seq = fields[6]
+            # Determine overlap with the block.
+            overlap_start = max(bed_start, block_ref_start)
+            overlap_end = min(bed_end, block_ref_start + block_ref_size)
+            if overlap_start >= overlap_end:
+                return None  # No overlap.
+            
+            # FIXED: Map the overlap to alignment columns correctly
+            current_ref = block_ref_start
+            col_start = None
+            col_end = None
+
+            for i, char in enumerate(ref_seq):
+                if char != '-':
+                    # This is a real reference position
+                    if current_ref >= overlap_start and col_start is None:
+                        col_start = i
+                    current_ref += 1
+                    if current_ref >= overlap_end:  # Check AFTER incrementing
+                        col_end = i + 1  # Include current position
+                        break
+                elif col_start is not None and col_end is None:
+                    # We're in our target region and this is a gap - we'll include it
+                    pass
+
+            if col_start is None:
+                return None
+            if col_end is None:
+                col_end = len(ref_seq)
+
+            if col_start is not None:
+                extracted_ref_bases = sum(1 for c in ref_seq[col_start:col_end] if c != '-')
+                expected_bases = overlap_end - overlap_start
+                if extracted_ref_bases != expected_bases:
+                    appendWarning(
+                        warning_state,
+                        f"Expected {expected_bases} bases but extracted {extracted_ref_bases} for region {overlap_start}-{overlap_end}",
+                    )
+
+            ref_col_start = col_start
+            ref_col_end = col_end       
+            new_ref_start = overlap_start
+            new_ref_size = sum(1 for c in ref_seq[ref_col_start:ref_col_end] if c != '-')
+            new_ref_end = new_ref_start + new_ref_size
+            new_fields = fields.copy()
+            new_fields[2] = str(new_ref_start)
+            new_fields[3] = str(new_ref_size)
+            new_fields[6] = ref_seq[ref_col_start:ref_col_end]
+            trimmed_lines.append(" ".join(new_fields))
+
+        else:
+            species_seq = fields[6]
+            offset_bases = sum(1 for c in species_seq[:ref_col_start] if c != '-')
+
+            trimmed_seq = species_seq[ref_col_start:ref_col_end]
+            trimmed_size = sum(1 for c in trimmed_seq if c != '-')       
+
+            original_start = int(fields[2])
+            strand = fields[4]
+            original_size = int(fields[3])
+            new_start = original_start + offset_bases
+            # if strand == '+':
+            #     new_start = original_start + offset_bases
+            # else:
+            #     new_start = original_start + (original_size - offset_bases - trimmed_size)                
+
+            new_fields = fields.copy()
+            new_fields[2] = str(new_start)
+            new_fields[3] = str(trimmed_size)
+            new_fields[6] = trimmed_seq
+            trimmed_lines.append(' '.join(new_fields))
+
+    #print(f"DEBUG: bed_interval=[{bed_start},{bed_end}), block_ref=[{block_ref_start},{block_ref_start + block_ref_size}), extracted_cols=[{ref_col_start}:{ref_col_end}], ref_seq_sample='{ref_seq[ref_col_start:ref_col_end] if ref_col_start is not None else 'None'}'", file=sys.stderr)
+
+    return "\n".join(trimmed_lines), [new_ref_start, new_ref_end, new_ref_size]
+
+#############################################################################
+
+def fetchByRegion(
+    region,
+    header,
+    maf_fp,
+    index,
+    output,
+    BATCHLOG,
+    single_output=False,
+    as_fasta=False,
+    fasta_header=False,
+    expected_species=None,
+    fasta_dedupe="none",
+    verbose=False,
+    warning_state=None,
+    profile_state=None,
+):
+    """
+    Worker function to process a single BED region:
+        - Opens the MAF file independently.
+        - Finds overlapping blocks in the index for region["scaffold"].
+        - For each overlapping block, fetches and trims the block to the 
+        exact [region["start"], region["end"]) interval on the reference.
+        - Writes the trimmed blocks to an output file, using region["output_basename"] as filename.
+    Returns a message summarizing the work.
+    """
+
+    scaffold = region["scaffold"]
+    bed_start = region["start"]
+    bed_end = region["end"]
+    out_basename = region["output_basename"]
+    region_str = f"{scaffold}\t{bed_start}\t{bed_end}\t{out_basename}"
+    region_timer_start = time.perf_counter() if profile_state is not None else None
+    # Parse region details
+
+    block_lengths = []  # Holds lengths of each block written
+    block_stats = []  # Holds [new_ref_start, new_ref_end, new_ref_size] for each block
+    total_ref_bases = 0 # Total ref bases across all blocks
+
+    if as_fasta:
+        fasta_seqs = defaultdict(dict);
+        species_order = expected_species[:] if expected_species else []
+        expected_species_set = set(expected_species) if expected_species else set()
+        use_species_keys = bool(expected_species) or fasta_dedupe != "none"
+        fill_cache = {}
+    # For fasta output, hold sequences per species
+
+    output_filename = os.path.join(output, out_basename + (".fa" if as_fasta else ".maf"))
+    out_stream = None
+
+    if single_output:
+        current_blocks = []
+    # Single output mode being developed !
+
+    blocks_written = 0;
+
+    if scaffold not in index:
+        appendWarning(warning_state, f"{scaffold}:{bed_start}-{bed_end} No index entries for scaffold.")
+        summary = f"{region_str}\t0\t0\tNA\t0"
+        return summary if not single_output else []
+
+    blocks_written = 0
+
+    scaffold_index = index[scaffold]
+    candidate_idx = bisect.bisect_left(scaffold_index["starts"], bed_start)
+    if candidate_idx > 0:
+        candidate_idx -= 1
+
+    scan_timer_start = time.perf_counter() if profile_state is not None else None
+    for entry in scaffold_index["entries"][candidate_idx:]:
+        if profile_state is not None:
+            profile_state["candidate_entries"] += 1
+        block_ref_start = entry["ref_start"]
+        block_ref_end = block_ref_start + entry["ref_length"]
+
+        if block_ref_end <= bed_start:
+            continue  # block before region
+
+        if block_ref_start >= bed_end:
+            break     # block after region
+
+        if bed_start < block_ref_end and bed_end > block_ref_start:
+            if profile_state is not None:
+                profile_state["overlap_blocks"] += 1
+            try:
+                read_timer_start = time.perf_counter() if profile_state is not None else None
+                maf_fp.seek(entry["offset_start"])
+                block_bytes = maf_fp.read(entry["offset_end"] - entry["offset_start"])
+                block_text = block_bytes.decode("utf-8", errors="replace")
+                if profile_state is not None:
+                    addProfile(profile_state, "time_read_decode", time.perf_counter() - read_timer_start)
+                #print(block_text.splitlines()[1])
+            except Exception as e:
+                BATCHLOG.error(f"Error fetching block: {e}")
+                raise
+
+            trim_timer_start = time.perf_counter() if profile_state is not None else None
+            trimmed_result = trimMafBlock(
+                block_text,
+                bed_start,
+                bed_end,
+                BATCHLOG,
+                verbose=verbose,
+                warning_state=warning_state,
+            )
+            if profile_state is not None:
+                addProfile(profile_state, "time_trim", time.perf_counter() - trim_timer_start)
+            if trimmed_result is None:
+                continue
+            trimmed, trimmed_info = trimmed_result
+
+            if not single_output and trimmed is not None:
+                block_stats.append(trimmed_info)
+                total_ref_bases += trimmed_info[2]                
+
+                if blocks_written == 0 and not as_fasta:
+                    out_stream = open(output_filename, "w", encoding="utf-8")
+                    out_stream.write(header)
+                    out_stream.write("## Extracted by mafutils fetch\n")
+                    out_stream.write("## Source MAF: " + os.path.basename(maf_fp.name) + "\n")
+                    out_stream.write(f"## Reference region: {region_str}\n")
+                    
+                if as_fasta:
+                    
+                    # Output as fasta
+                    fasta_block_timer_start = time.perf_counter() if profile_state is not None else None
+                    return_fasta_seqs, block_len = mafBlockToFasta(
+                        trimmed,
+                        region,
+                        dedupe_mode=fasta_dedupe,
+                        use_species_keys=use_species_keys
+                    )
+                    if profile_state is not None:
+                        addProfile(profile_state, "time_block_to_fasta", time.perf_counter() - fasta_block_timer_start)
+                    #fasta_lines[src] = {'header': header, 'seq': seq, 'start': start, 'end': end, 'strand': strand}
+                    block_lengths.append(block_len)
+
+                    stitch_timer_start = time.perf_counter() if profile_state is not None else None
+                    if expected_species:
+                        for sp in expected_species:
+                            if sp not in return_fasta_seqs:
+                                return_fasta_seqs[sp] = {
+                                    'seq': getFillString(fill_cache, "N", block_len),
+                                    'start': None,
+                                    'end': None,
+                                    'strand': None
+                                }
+
+                    # For any new species, add to order and backfill
+                    for sp in return_fasta_seqs:
+                        if sp not in species_order:
+                            species_order.append(sp)
+                        if sp not in fasta_seqs:
+                            # Backfill for all previous blocks
+                            fasta_seqs[sp]['seq'] = [getFillString(fill_cache, "-", l) for l in block_lengths[:-1]]
+                            fasta_seqs[sp]['starts'] = []
+                            fasta_seqs[sp]['ends'] = []
+                            fasta_seqs[sp]['strands'] = []
+
+                    # After establishing all species, append current block or pad as needed
+                    for sp in species_order:
+                        if sp in return_fasta_seqs:
+                            seq = return_fasta_seqs[sp]['seq']
+                        else:
+                            fill_char = "N" if sp in expected_species_set else "-"
+                            seq = getFillString(fill_cache, fill_char, block_len)
+                        fasta_seqs[sp]['seq'].append(seq)
+                        if sp in return_fasta_seqs:
+                            if return_fasta_seqs[sp]['start'] is not None:
+                                fasta_seqs[sp]['starts'].append(return_fasta_seqs[sp]['start'])
+                            if return_fasta_seqs[sp]['end'] is not None:
+                                fasta_seqs[sp]['ends'].append(return_fasta_seqs[sp]['end'])
+                            if return_fasta_seqs[sp]['strand'] is not None:
+                                fasta_seqs[sp]['strands'].append(return_fasta_seqs[sp]['strand'])
+                    if profile_state is not None:
+                        addProfile(profile_state, "time_fasta_stitch", time.perf_counter() - stitch_timer_start)
+                else:
+                    out_stream.write(trimmed + "\n")
+                blocks_written += 1
+            elif single_output and trimmed is not None:
+                if as_fasta:
+                    return_fasta_seqs, _ = mafBlockToFasta(
+                        trimmed,
+                        region,
+                        dedupe_mode=fasta_dedupe,
+                        use_species_keys=use_species_keys
+                    )
+                    current_blocks.append(return_fasta_seqs)
+                else:
+                    current_blocks.append(trimmed + "\n")
+
+    if as_fasta and not single_output and blocks_written > 0:
+        out_stream = open(output_filename, "w", encoding="utf-8")
+        # Write all fasta sequences to the output
+        write_timer_start = time.perf_counter() if profile_state is not None else None
+        writeFASTA(
+            fasta_seqs,
+            region,
+            out_stream,
+            BATCHLOG,
+            fasta_header=fasta_header,
+            verbose=verbose,
+            warning_state=warning_state,
+        )
+        if profile_state is not None:
+            addProfile(profile_state, "time_write_fasta", time.perf_counter() - write_timer_start)
+
+    if not blocks_written:
+        appendWarning(warning_state, f"{scaffold}:{bed_start}-{bed_end} No overlapping blocks found.")
+
+    if not single_output:
+        if out_stream is not None:
+            out_stream.close()
+        # --- BEGIN SUMMARY REPORT ---
+        # Collect region info
+        block_stats.sort()
+        
+        interblock_spaces = [
+            block_stats[i][0] - block_stats[i-1][1]
+            for i in range(1, len(block_stats))
+        ] if len(block_stats) > 1 else []
+
+        num_blocks = len(block_stats)
+        blocks_length = sum(info[2] for info in block_stats)
+        space_str = str(interblock_spaces) if interblock_spaces else "NA"
+        if profile_state is not None:
+            profile_state["regions"] += 1
+            addProfile(profile_state, "time_index_scan", time.perf_counter() - scan_timer_start)
+            addProfile(profile_state, "time_region_total", time.perf_counter() - region_timer_start)
+        summary = (f"{region_str}\t{num_blocks}\t{blocks_length}\t{space_str}\t{len(species_order) if as_fasta else 'NA'}")
+        return summary
+
+    else:
+        if profile_state is not None:
+            profile_state["regions"] += 1
+            addProfile(profile_state, "time_index_scan", time.perf_counter() - scan_timer_start)
+            addProfile(profile_state, "time_region_total", time.perf_counter() - region_timer_start)
+        return current_blocks;
+
+#############################################################################
+
+def fetchByBatch(
+    batch,
+    batch_num,
+):
+
+    BATCHLOG = logging.getLogger("maf_fetch_logger")
+    plural = "s" if len(batch) > 1 else ""
+    BATCHLOG.info(f"Processing batch {batch_num} with {len(batch)} region{plural}")
+    BATCHLOG.debug(f">> (first: {batch[0]['scaffold']}:{batch[0]['start']}-{batch[0]['end']}, last: {batch[-1]['scaffold']}:{batch[-1]['start']}-{batch[-1]['end']})")
+    # Initialize batch-specific logger
+
+    maf_fp = WORKER_MAF_FP
+    if maf_fp is None:
+        BATCHLOG.error(f"Batch {batch_num}: Worker MAF handle is not initialized.")
+        raise RuntimeError("Worker MAF handle is not initialized.")
+
+    batch_results = [None] * len(batch)
+    region_num = 0
+    zero_overlap_regions = 0
+    success_regions = 0
+    warning_state = {"count": 0, "messages": [] if WORKER_VERBOSE else None}
+    profile_state = initProfileState() if WORKER_PROFILE else None
+    batch_timer_start = time.perf_counter() if WORKER_PROFILE else None
+
+    ordered_regions = sorted(
+        enumerate(batch),
+        key=lambda item: (
+            item[1]["scaffold"],
+            item[1]["start"],
+            item[1]["end"],
+            item[0],
+        ),
+    )
+
+    for batch_order, (result_idx, region) in enumerate(ordered_regions, start=1):
+        region_num += 1
+
+        batch_str = f" [batch {batch_num}.{batch_order}]"
+        BATCHLOG.debug(f">>>{batch_str} Region {region['scaffold']}:{region['start']}-{region['end']}")
+
+        region_result = fetchByRegion(
+            region,
+            WORKER_HEADER,
+            maf_fp,
+            WORKER_INDEX,
+            WORKER_OUTPUT,
+            BATCHLOG,
+            as_fasta=WORKER_AS_FASTA,
+            fasta_header=WORKER_FASTA_HEADER,
+            expected_species=WORKER_EXPECTED_SPECIES,
+            fasta_dedupe=WORKER_FASTA_DEDUPE,
+            verbose=WORKER_VERBOSE,
+            warning_state=warning_state,
+            profile_state=profile_state,
+        )
+        batch_results[result_idx] = region_result
+        if not WORKER_SINGLE_OUTPUT:
+            fields = region_result.split("\t")
+            if len(fields) >= 5:
+                try:
+                    if int(fields[4]) == 0:
+                        zero_overlap_regions += 1
+                    else:
+                        success_regions += 1
+                except ValueError:
+                    pass
+    if profile_state is not None:
+        profile_state["time_batch_total"] = time.perf_counter() - batch_timer_start
+
+    return {
+        "results": batch_results,
+        "processed_regions": len(batch_results),
+        "zero_overlap_regions": zero_overlap_regions,
+        "batch_num": batch_num,
+        "success_regions": success_regions,
+        "warning_count": warning_state["count"],
+        "warning_messages": warning_state["messages"],
+        "profile": profile_state,
+    }
+
+#############################################################################
+
+def fetchByScaffold(scaffold, start_end, maf_file, maf_header, maf_compression, out_dir, LOG):
+    """
+    Worker function to extract one scaffold from the MAF file.
+    start_end is a tuple (start_byte, end_byte).
+    """
+    start, end = start_end
+    output_path = os.path.join(out_dir, f"{scaffold}.maf")
+
+    # Open MAF file appropriately
+    opener = gzip.open if maf_compression == "gz" else open
+
+    try:
+        with opener(maf_file, "rb") as mfp, open(output_path, "wb") as outfp:
+            LOG.info(f">>> Scaffold {scaffold}");
+            mfp.seek(start)
+            data = mfp.read(end - start)
+            outfp.write(maf_header.encode("utf-8"))
+            outfp.write(data)
+    except Exception as e:
+        LOG.error(f"{scaffold}: {e}")
+    
+    return f"{output_path}: Wrote {scaffold}";
+
+
+#############################################################################
+
+def run_fetch(args, cmdline="mafutils fetch"):
+
+    logfilename = os.path.join(args.output, "maf_fetch.log") if os.path.isdir(args.output) else "maf_fetch.log"
+    maf_fetch_logger = LOGINIT.configureLogging(log_level="INFO", log_verbosity="BOTH", log_filename=logfilename, logger_name="maf_fetch_logger")
+    LOG = logging.getLogger(maf_fetch_logger)
+    # Set up logging
+
+    LOG.info(f"mafutils fetch called as: {cmdline}");
+    LOG.info("-" * 40);
+    for arg, value in vars(args).items():
+        valstr = str(value)
+        if len(valstr) > 80:
+            valstr = valstr[:77] + "..."
+        LOG.info(f"{arg:20} : {valstr}")
+    LOG.info("-" * 40 )
+    # Log the command line arguments
+
+    if args.mode not in ("block", "scaffold"):
+        LOG.error(f"Invalid mode: '{args.mode}'. Must be 'block' or 'scaffold'.")
+        sys.exit(1)
+    # Validate mode
+    # if args.max_no_overlap_regions < -1:
+    #     LOG.error("--max-no-overlap-regions must be >= -1.")
+    #     sys.exit(1)
+    # if args.max_no_overlap_fraction < 0.0 or args.max_no_overlap_fraction > 1.0:
+    #     LOG.error("--max-no-overlap-fraction must be between 0 and 1.")
+    #     sys.exit(1)
+
+    maf_compression = COMMON.detectCompression(args.maf_file);
+    if not args.single_output:
+        os.makedirs(args.output, exist_ok=True);
+    # Create output directory if it doesn't exist
+
+    LOG.info(f"Parsing index file.... {args.index_file}");
+    index = parseIndex(args.index_file, LOG, args.mode);
+
+    LOG.info(f"Parsing BED file...... {args.bed_file}");
+    regions = parseBed(args.bed_file, LOG, args.mode);
+
+    expected_species = parseExpectedSpecies(args)
+    if expected_species:
+        LOG.info(f"Loaded {len(expected_species)} expected species for FASTA missing-species filling.")
+
+    LOG.info(f"Getting MAF header.... {args.maf_file}");
+    maf_header = getMAFHeader(args.maf_file, maf_compression);
+
+    ##############################
+    # SCAFFOLD MODE
+    ##############################
+
+    if args.mode == "scaffold":
+        if args.single_output:
+            LOG.error("--single-output cannot be used in scaffold mode.");
+            sys.exit(1)
+
+        if args.fasta:
+            LOG.error("FASTA output not supported in scaffold mode.")
+            sys.exit(1)
+        if expected_species:
+            LOG.error("--expected-species/--expected-species-file can only be used in block mode with --fasta.")
+            sys.exit(1)
+        if args.fasta_dedupe != "none":
+            LOG.error("--fasta-dedupe can only be used in block mode with --fasta.")
+            sys.exit(1)
+
+        LOG.info(f"Running in SCAFFOLD mode with BED + region index");
+        
+        # Parse the BED file to get a set of scaffolds to extract
+        scaffold_set = set(region["scaffold"] for region in regions);
+        LOG.info(f"Extracting {len(scaffold_set)} scaffolds from scaffold index: {scaffold_set}");
+
+        # Extract from MAF using the region index for matching scaffolds
+        with ProcessPoolExecutor(max_workers=args.processes) as executor:
+            futures = []
+            for scaffold in scaffold_set:
+                if scaffold not in index:
+                    LOG.error(f"Scaffold '{scaffold}' not found in index.")
+                    sys.exit(1)
+                start, end = index[scaffold]
+                futures.append(executor.submit(
+                    fetchByScaffold,
+                    scaffold,
+                    (start, end),
+                    args.maf_file,
+                    maf_header,
+                    maf_compression,
+                    args.output,
+                    LOG
+                ))
+            for future in futures:
+                result = future.result()
+                LOG.info(result)
+        return;  # Done with scaffold mode
+
+    ##############################
+    # BLOCK MODE (default)
+    ##############################
+
+    LOG.info(f"Running in BLOCK mode");
+    if expected_species and not args.fasta:
+        LOG.error("--expected-species/--expected-species-file require --fasta.")
+        sys.exit(1)
+    if args.fasta_dedupe != "none" and not args.fasta:
+        LOG.error("--fasta-dedupe requires --fasta.")
+        sys.exit(1)
+
+    num_regions = len(regions);
+    batch_size = pick_chunk_size(num_regions, args.processes);
+    if batch_size >= num_regions:
+        batch_size = 1
+    LOG.info(f"Using batch size of {batch_size} regions for {num_regions} total regions with {args.processes} processes.");
+    batches = list(chunker(regions, size=batch_size))
+    LOG.info(f"Divided {len(regions)} regions into {len(batches)} batches of up to {batch_size} regions each.");
+    # Region batching for parallel processing
+
+    if args.single_output:
+        if args.output == "." or os.path.isdir(args.output):
+            output_file = "maf-fetch.maf"
+        else:
+            if os.path.isdir(args.output):
+                LOG.error("--single-output cannot be used with --outdir. Use current directory only.");
+                sys.exit(1)
+            output_file = args.output
+        LOG.info(f"Using single output file: {output_file}")
+    ## Single output mode being developed !
+
+    # Pre-assign output basenames for regions.
+    # For regions missing a 4th column (basename), assign a unique counter per scaffold.
+    region_counter = {}
+    for region in regions:
+        scaffold = region["scaffold"]
+        start = region["start"]
+        end = region["end"]
+        basename_mode = args.basename
+
+        if basename_mode == "id":
+            if region.get("id"):
+                region["output_basename"] = region["id"]
+            else:
+                LOG.error(f"Basename mode set to 'id', but '{region}' lacks an ID (4th column).");
+        elif basename_mode == "count":
+            count = region_counter.get(scaffold, 0) + 1
+            region_counter[scaffold] = count
+            region["output_basename"] = f"{scaffold}.{count}"
+        else: # basename_mode == "coords":
+            region["output_basename"] = f"{scaffold}-{start}-{end}"
+
+    info_outfile = os.path.join(args.output, "maf_fetch_summary.tsv")
+
+    # if args.fasta_header and not args.fasta:
+    #     LOG.warning("--fasta-header is only used with --fasta output. Ignoring.");
+
+    # Process each batch in parallel.
+    results = [];
+    total_regions_reported = 0
+    zero_overlap_regions = 0
+    fail_fast_triggered = False
+    fail_fast_message = None
+    profile_totals = initProfileState() if args.profile else None
+    profiled_batches = 0
+    with ProcessPoolExecutor(
+        max_workers=args.processes,
+        initializer=initBatchWorker,
+        initargs=(
+            maf_header,
+            args.maf_file,
+            maf_compression,
+            index,
+            args.output,
+            args.single_output,
+            args.fasta,
+            args.fasta_header,
+            expected_species,
+            args.fasta_dedupe,
+            args.verbose,
+            args.profile,
+        ),
+    ) as executor, open(info_outfile, "w") as info_out:
+        summary_headers = ["scaffold", "start", "end", "basename", "n.overlapping.blocks", "block.lengths", "interblock.distances", "n.sequences"]
+        info_out.write("\t".join(summary_headers) + "\n")
+
+        futures = {}
+        for batch_num, batch in enumerate(batches, start=1):
+            future = executor.submit(
+                fetchByBatch,
+                batch,
+                batch_num,
+            )
+            futures[future] = batch_num
+
+        while futures:
+            done, _pending = wait(list(futures.keys()), return_when=FIRST_COMPLETED)
+            for future in done:
+                batch_num = futures.pop(future)
+                result = future.result()
+                if args.profile and result["profile"] is not None:
+                    profiled_batches += 1
+                    for key, value in result["profile"].items():
+                        profile_totals[key] += value
+
+                if not args.single_output:
+                    for r in result["results"]:
+                        info_out.write(r + "\n")
+                    total_regions_reported += result["processed_regions"]
+                    zero_overlap_regions += result["zero_overlap_regions"]
+
+                    if result["warning_count"] > 0:
+                        if args.verbose:
+                            for warning_message in result["warning_messages"]:
+                                LOG.warning(warning_message)
+                        else:
+                            LOG.warning(
+                                "Batch %d produced %d warning%s.",
+                                result["batch_num"],
+                                result["warning_count"],
+                                "" if result["warning_count"] == 1 else "s",
+                            )
+
+                    zero_overlap_fraction_final_floor = zero_overlap_regions / num_regions if num_regions else 0.0
+
+                    LOG.info(
+                        "Completed batch %d: %d successful / %d warn / %d total",
+                        result["batch_num"],
+                        result["success_regions"],
+                        result["zero_overlap_regions"],
+                        result["processed_regions"],
+                    )
+
+                    if zero_overlap_regions > MAX_NO_OVERLAP_REGIONS_DEFAULT:
+                        fail_fast_triggered = True
+                        fail_fast_message = (
+                            f"Zero-overlap regions ({zero_overlap_regions}) exceeded hardcoded max "
+                            f"({MAX_NO_OVERLAP_REGIONS_DEFAULT}). Failing run."
+                        )
+                    elif zero_overlap_fraction_final_floor > MAX_NO_OVERLAP_FRACTION_DEFAULT:
+                        fail_fast_triggered = True
+                        fail_fast_message = (
+                            f"Zero-overlap fraction cannot recover below hardcoded max "
+                            f"({MAX_NO_OVERLAP_FRACTION_DEFAULT:.6f}); current lower bound is "
+                            f"{zero_overlap_fraction_final_floor:.6f}. Failing run."
+                        )
+                else:
+                    results.append(result["results"])
+
+            if fail_fast_triggered:
+                for pending_future in futures:
+                    pending_future.cancel()
+                break
+
+    if fail_fast_triggered:
+        LOG.error(fail_fast_message)
+        sys.exit(2)
+
+    if args.profile and profile_totals is not None and profiled_batches > 0:
+        LOG.info("Profile summary across %d batch(es):", profiled_batches)
+        LOG.info(
+            "Profile regions=%d candidate_entries=%d overlap_blocks=%d",
+            profile_totals["regions"],
+            profile_totals["candidate_entries"],
+            profile_totals["overlap_blocks"],
+        )
+        LOG.info(
+            "Profile time_batch_total=%.3fs time_region_total=%.3fs time_index_scan=%.3fs "
+            "time_read_decode=%.3fs time_trim=%.3fs time_block_to_fasta=%.3fs "
+            "time_fasta_stitch=%.3fs time_write_fasta=%.3fs",
+            profile_totals.get("time_batch_total", 0.0),
+            profile_totals["time_region_total"],
+            profile_totals["time_index_scan"],
+            profile_totals["time_read_decode"],
+            profile_totals["time_trim"],
+            profile_totals["time_block_to_fasta"],
+            profile_totals["time_fasta_stitch"],
+            profile_totals["time_write_fasta"],
+        )
+
+    if not args.single_output and total_regions_reported > 0 and zero_overlap_regions > 0:
+        zero_overlap_fraction = zero_overlap_regions / total_regions_reported
+        LOG.warning(
+            "%d of %d regions had no overlapping MAF blocks (%.6f).",
+            zero_overlap_regions,
+            total_regions_reported,
+            zero_overlap_fraction,
+        )
+        if zero_overlap_regions == total_regions_reported:
+            LOG.error("No regions overlapped any MAF block. Failing run.")
+            sys.exit(2)
+        if (
+            MAX_NO_OVERLAP_REGIONS_DEFAULT >= 0
+            and zero_overlap_regions > MAX_NO_OVERLAP_REGIONS_DEFAULT
+        ):
+            LOG.error(
+                "Zero-overlap regions (%d) exceeded hardcoded max (%d). Failing run.",
+                zero_overlap_regions,
+                MAX_NO_OVERLAP_REGIONS_DEFAULT,
+            )
+            sys.exit(2)
+        if zero_overlap_fraction > MAX_NO_OVERLAP_FRACTION_DEFAULT:
+            LOG.error(
+                "Zero-overlap fraction (%.6f) exceeded hardcoded max (%.6f). Failing run.",
+                zero_overlap_fraction,
+                MAX_NO_OVERLAP_FRACTION_DEFAULT,
+            )
+            sys.exit(2)
+
+    # if args.single_output:
+    #     with open(output_file, "w", encoding="utf-8") as out_stream:
+    #         if not args.fasta:
+    #             out_stream.write(maf_header)  # Write header to single output file
+
+    #         total_blocks = 0
+    #         for block_list in results:
+    #             if block_list:  # block_list is now a list of strings
+    #                 for block in block_list:
+    #                     out_stream.write(block)
+    #                     total_blocks += 1
+
+    #     LOG.info(f"Single output file written: {output_file} ({total_blocks} blocks)")
+
+
+def fetch_command(
+    maf_file: Annotated[str, typer.Argument(help="Input MAF file (.maf or .maf.gz)")],
+    index_file: Annotated[str, typer.Argument(help="Index file (block-level .idx or scaffold-level .idx)")],
+    bed_file: Annotated[str, typer.Argument(help="BED file with regions or scaffold names to extract")],
+    basename: Annotated[BasenameMode, typer.Option("--basename", "-b", help="Basename strategy: 'id' (BED 4th col if present), 'coords' (scaffold-start-end), or 'count' (numbered per scaffold)")] = BasenameMode.coords,
+    output: Annotated[str, typer.Option("--output", "-o", help="Output directory (default: current directory); if --single-output is used, this should instead be a filename and will default to maf-fetch.maf in the current directory.")] = ".",
+    fasta: Annotated[bool, typer.Option("--fasta", "-f", help="Output region(s) in FASTA format instead of MAF.")] = False,
+    fasta_header: Annotated[FastaHeaderMode, typer.Option("--fasta-header", "-fh", help="Controls the FASTA header format: 'species-coords-id' (default, includes species, coordinates, and region ID if present),'species-coords' (species and coordinates only), or 'species-only' (just the species name).")] = FastaHeaderMode.species_coords,
+    expected_species: Annotated[str, typer.Option("--expected-species", help="Comma-separated species list expected in FASTA output; missing species are filled per block with Ns.")] = "",
+    expected_species_file: Annotated[str, typer.Option("--expected-species-file", help="File with one expected species name per line for FASTA missing-species filling.")] = "",
+    fasta_dedupe: Annotated[FastaDedupeMode, typer.Option("--fasta-dedupe", help="When outputting FASTA, collapse duplicate species per block; 'most-seq' keeps the copy with most non-gap bases.")] = FastaDedupeMode.none,
+    processes: Annotated[int, typer.Option("--processes", "-p", help="Number of parallel processes to use (default: 1)")] = 1,
+    mode: Annotated[FetchMode, typer.Option("--mode", "-m", help="Mode: 'block' to trim by regions, 'scaffold' to extract whole scaffolds (default: block)")] = FetchMode.block,
+    single_output: Annotated[bool, typer.Option("--single-output", hidden=True)] = False,
+    verbose: Annotated[bool, typer.Option("--verbose", help="Print every warning line after each batch completes.")] = False,
+    profile: Annotated[bool, typer.Option("--profile", help="Log aggregate timing breakdowns for internal fetch steps.")] = False,
+) -> None:
+    args = SimpleNamespace(
+        maf_file=maf_file,
+        index_file=index_file,
+        bed_file=bed_file,
+        basename=basename.value,
+        output=output,
+        fasta=fasta,
+        fasta_header=fasta_header.value,
+        expected_species=expected_species,
+        expected_species_file=expected_species_file,
+        fasta_dedupe=fasta_dedupe.value,
+        processes=processes,
+        mode=mode.value,
+        single_output=single_output,
+        verbose=verbose,
+        profile=profile,
+    )
+    cmdline = "mafutils fetch"
+    if len(sys.argv) > 2:
+        cmdline += " " + " ".join(sys.argv[2:])
+    run_fetch(args, cmdline=cmdline)