krewlyzer 0.1.0__py3-none-any.whl

krewlyzer/fsr.py

@@ -0,0 +1,171 @@
+import typer
+from pathlib import Path
+from typing import Optional
+import logging
+import sys
+
+import pysam
+import pybedtools
+import numpy as np
+from rich.console import Console
+from rich.logging import RichHandler
+
+console = Console()
+logging.basicConfig(level="INFO", handlers=[RichHandler(console=console)], format="%(message)s")
+logger = logging.getLogger("fsr")
+
+from .helpers import gc_correct
+
+def _calc_fsr(bedgz_input, bin_input, windows, continue_n, output_file):
+    """
+    Internal: Calculate fragment size ratio (FSR) for a single .bed.gz file.
+    Writes region-based ratios for short, intermediate, and long fragments.
+    """
+    try:
+        logger.info(f"input file: {bedgz_input}, {bin_input}")
+        try:
+            inputbed = pysam.Tabixfile(filename=bedgz_input, mode="r")
+        except Exception as e:
+            logger.error(f"Could not open {bedgz_input} as Tabix file: {e}")
+            raise typer.Exit(1)
+        try:
+            bins = pybedtools.BedTool(bin_input)
+        except Exception as e:
+            logger.error(f"Could not load bins from {bin_input}: {e}")
+            raise typer.Exit(1)
+        length = len(bins)
+        shorts_data, intermediates_data, longs_data, totals_data, bingc = [], [], [], [], []
+        chrom = []
+        logger.info(f"output file: {output_file}")
+        for idx in range(length):
+            bin = bins[idx]
+            try:
+                chrom.append(bin.chrom)
+                inputbed.fetch(bin.chrom, bin.start, bin.end)
+            except ValueError:
+                bingc.append(np.nan)
+                shorts_data.append(0)
+                intermediates_data.append(0)
+                longs_data.append(0)
+            except Exception as e:
+                logger.error(f"Error fetching bin {bin}: {e}")
+                raise typer.Exit(1)
+            else:
+                bin_data = []
+                gc = []
+                try:
+                    for read in inputbed.fetch(bin.chrom, bin.start, bin.end):
+                        bin_data.append(int(read.split("\t")[2]) - int(read.split("\t")[1]))
+                        if 65 <= int(read.split("\t")[2]) - int(read.split("\t")[1]) <= 400:
+                            gc.append(float(read.split("\t")[3]))
+                    count = np.bincount(bin_data, minlength=401)
+                except Exception as e:
+                    logger.error(f"Error processing reads in bin {bin}: {e}")
+                    raise typer.Exit(1)
+                if len(gc) == 0:
+                    bingc.append(np.nan)
+                else:
+                    bingc.append(np.mean(gc))
+                shorts = sum(count[65:150])
+                intermediates = sum(count[151:260])
+                longs = sum(count[261:400])
+                totals = sum(count[65:400])
+                if totals == 0:
+                    shorts_data.append(0)
+                    intermediates_data.append(0)
+                    longs_data.append(0)
+                else:
+                    shorts_data.append(shorts / totals)
+                    intermediates_data.append(intermediates / totals)
+                    longs_data.append(longs / totals)
+        start = 0
+        step = 0
+        try:
+            with open(output_file, 'w') as fsrfile:
+                fsrfile.write("region\tshort-ratio\titermediate-ratio\tlong-ratio\n")
+                while step < length:
+                    num = chrom.count(chrom[step])
+                    continues_bin = num // continue_n
+                    last_bin = num % continue_n
+                    for _ in range(continues_bin):
+                        bin_start = start * windows
+                        bin_end = (start + continue_n) * windows - 1
+                        combine_shorts = shorts_data[step: step + continue_n]
+                        combine_intermediates = intermediates_data[step: step + continue_n]
+                        combine_longs = longs_data[step: step + continue_n]
+                        tmp_array = np.zeros(3)
+                        tmp_array[0] = np.mean(combine_shorts)
+                        tmp_array[1] = np.mean(combine_intermediates)
+                        tmp_array[2] = np.mean(combine_longs)
+                        region = f"{chrom[step]}:{bin_start}-{bin_end}"
+                        temp_str = f"{region}\t" + "\t".join(map(str, tmp_array)) + "\n"
+                        fsrfile.write(temp_str)
+                        step += continue_n
+                        start += continue_n
+                    if last_bin != 0:
+                        step += last_bin
+                        start = 0
+        except Exception as e:
+            logger.error(f"Error writing FSR output file: {e}")
+            raise typer.Exit(1)
+        logger.info(f"FSR calculation complete. Results written to {output_file}")
+    except Exception as e:
+        logger.error(f"Fatal error in _calc_fsr: {e}")
+        raise typer.Exit(1)
+
+def fsr(
+    bedgz_path: Path = typer.Argument(..., help="Folder containing .bed.gz files (should be the output directory from motif.py)"),
+    bin_input: Optional[Path] = typer.Option(None, "--bin-input", "-b", help="Path to bin file (default: data/ChormosomeBins/hg19_window_100kb.bed)"),
+    windows: int = typer.Option(100000, "--windows", "-w", help="Window size (default: 100000)"),
+    continue_n: int = typer.Option(50, "--continue-n", "-c", help="Consecutive window number (default: 50)"),
+    output: Path = typer.Option(..., "--output", "-o", help="Output folder for results"),
+    threads: int = typer.Option(1, "--threads", "-t", help="Number of parallel processes (default: 1)")
+):
+    """
+    Calculate fragment size ratio (FSR) features for all .bed.gz files in a folder.
+    """
+    # Input checks
+    if not bedgz_path.exists():
+        logger.error(f"Input directory not found: {bedgz_path}")
+        raise typer.Exit(1)
+    if bin_input and not bin_input.exists():
+        logger.error(f"Bin input file not found: {bin_input}")
+        raise typer.Exit(1)
+    try:
+        output.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        logger.error(f"Could not create output directory {output}: {e}")
+        raise typer.Exit(1)
+    """
+    The input folder should be the output directory produced by motif.py, containing the .bed.gz files.
+    Output files are written to the output directory, one per .bed.gz file.
+    """
+    if not output.exists():
+        output.mkdir(parents=True, exist_ok=True)
+    bedgz_files = [f for f in bedgz_path.iterdir() if f.suffixes == ['.bed', '.gz']]
+    if not bedgz_files:
+        logger.error("No .bed.gz files found in the specified folder.")
+        raise typer.Exit(1)
+    if bin_input is None:
+        bin_input = Path(__file__).parent / "data" / "ChormosomeBins" / "hg19_window_100kb.bed"
+        logger.info(f"No bin_input specified. Using default: {bin_input}")
+    if not bin_input.exists():
+        logger.error(f"Bin input file does not exist: {bin_input}")
+        raise typer.Exit(1)
+    logger.info(f"Calculating FSR for {len(bedgz_files)} files...")
+    from concurrent.futures import ProcessPoolExecutor, as_completed
+    logger.info(f"Starting parallel FSR calculation using {threads} processes...")
+    def run_fsr_file(bedgz_file):
+        output_file = output / (bedgz_file.stem.replace('.bed', '') + '.FSR.txt')
+        _calc_fsr(str(bedgz_file), str(bin_input), windows, continue_n, str(output_file))
+        return str(output_file)
+    with ProcessPoolExecutor(max_workers=threads) as executor:
+        futures = {executor.submit(run_fsr_file, bedgz_file): bedgz_file for bedgz_file in bedgz_files}
+        for future in as_completed(futures):
+            bedgz_file = futures[future]
+            try:
+                result = future.result()
+                logger.info(f"FSR calculated: {result}")
+            except Exception as exc:
+                logger.error(f"FSR calculation failed for {bedgz_file}: {exc}")
+    logger.info(f"FSR features calculated for {len(bedgz_files)} files.")

krewlyzer/helpers.py

@@ -0,0 +1,187 @@
+import pysam
+import itertools
+import os
+import numpy as np
+import pandas as pd
+import math
+from collections import defaultdict
+from rich.logging import RichHandler
+import logging
+from skmisc.loess import loess
+import numpy as np
+
+logging.basicConfig(level="INFO", handlers=[RichHandler()], format="%(message)s")
+logger = logging.getLogger("krewlyzer-helpers")
+
+def gc_correct(coverage, bias):
+    """
+    Perform GC bias correction on coverage values using LOESS regression.
+    Logs errors and raises commonError if fitting fails.
+    """
+    covl = len(coverage)
+    valid = [True for _ in range(covl)]
+    temp_cov = []
+    temp_bias = []
+    for i in range(covl):
+        if np.isnan(bias[i]):
+            valid[i] = False
+        else:
+            temp_cov.append(coverage[i])
+            temp_bias.append(bias[i])
+    if not temp_cov or not temp_bias:
+        logger.error("No valid coverage/bias values for GC correction.")
+        raise commonError("No valid coverage/bias values for GC correction.")
+    med = np.median(temp_cov)
+    correct_cov = []
+    try:
+        i = np.arange(np.min(temp_bias), np.max(temp_bias), 0.001)
+        coverage_trend = loess(temp_bias, temp_cov, span=0.75)
+        coverage_trend.fit()
+        coverage_model = loess(i, coverage_trend.predict(i, stderror=True).values)
+        coverage_model.fit()
+        coverage_pred = coverage_model.predict(temp_bias, stderror=True)
+        pred = np.array(coverage_pred.values)
+        coverage_corrected = temp_cov - pred + med
+    except Exception as e:
+        logger.error(f"GC correction failed: {e}")
+        raise commonError(f"GC correction failed: {e}")
+    i, j = 0, 0
+    while i < covl:
+        if valid[i]:
+            if coverage_corrected[j] < 0:
+                correct_cov.append(0)
+            else:
+                correct_cov.append(coverage_corrected[j])
+            j += 1
+        else:
+            correct_cov.append(0)
+        i += 1
+    return correct_cov
+
+class commonError(Exception):
+    def __init__(self, message):
+        logger.error(f"commonError: {message}")
+        self.message = message
+
+def maxCore(nCore=None):
+    if nCore and nCore > 16:
+        logger.warning("Requested nCore > 16; capping to 16.")
+        return 16
+    else:
+        return nCore
+
+# Alias for CLI import consistency
+max_core = maxCore
+
+def rmEndString(x, y):
+    for item in y:
+        if x.endswith(item):
+            x = x.replace(item, "")
+    return x
+
+def isSoftClipped(cigar):
+    """
+    cigar information:
+    S	BAM_CSOFT_CLIP	4
+    H	BAM_CHARD_CLIP	5
+    P	BAM_CPAD	6
+    """
+    for (op, count) in cigar:
+        if op in [4, 5, 6]:
+            return True
+    return False
+
+def GCcontent(seq):
+    try:
+        nA = seq.count("a") + seq.count("A")
+        nT = seq.count("t") + seq.count("T")
+        nG = seq.count("g") + seq.count("G")
+        nC = seq.count("c") + seq.count("C")
+        percent_GC = (nG + nC) / (nA + nT + nG + nC) if (nA + nT + nG + nC) > 0 else 0
+        return percent_GC
+    except Exception as e:
+        logger.error(f"GCcontent calculation failed: {e}")
+        return 0
+
+def read_pair_generator(bam, region_string=None):
+    """
+    Generate read pairs in a BAM file or within a region string.
+    Reads are added to read_dict until a pair is found.
+    Reference: https://www.biostars.org/p/306041/
+    """
+    read_dict = defaultdict(lambda: [None, None])
+    try:
+        for read in bam.fetch(region=region_string):
+            if read.is_unmapped or read.is_qcfail or read.is_duplicate:
+                continue
+            if not read.is_paired or not read.is_proper_pair:
+                continue
+            if read.is_secondary or read.is_supplementary:
+                continue
+            if read.mate_is_unmapped:
+                continue
+            if read.rnext != read.tid:
+                continue
+            if read.template_length == 0:
+                continue
+            if isSoftClipped(read.cigar):
+                continue
+            qname = read.query_name
+            if qname not in read_dict:
+                if read.is_read1:
+                    read_dict[qname][0] = read
+                else:
+                    read_dict[qname][1] = read
+            else:
+                if read.is_read1:
+                    yield read, read_dict[qname][1]
+                else:
+                    yield read_dict[qname][0], read
+                del read_dict[qname]
+    except Exception as e:
+        logger.error(f"Error during BAM read pair generation: {e}")
+        return
+
+def reverse_seq(seq):
+    r_seq = ''
+    for i in seq:
+        if i == 'A':
+            r_seq += 'T'
+        elif i == 'T':
+            r_seq += 'A'
+        elif i == 'C':
+            r_seq += 'G'
+        elif i == 'G':
+            r_seq += 'C'
+        else:
+            r_seq += i
+    return r_seq
+
+def get_End_motif(Emotif, seq1, seq2):
+    if seq1.count('N') + seq1.count('n') + seq2.count('N') + seq2.count('n') != 0:
+        return Emotif
+    seq2 = reverse_seq(seq2)
+    if seq1 in Emotif.keys():
+        Emotif[seq1] += 1
+    if seq2 in Emotif.keys():
+        Emotif[seq2] += 1
+    return Emotif
+
+def calc_MDS(inputEndMotifFile, outputfile):
+    inputfile = pd.read_table(inputEndMotifFile, header=None, names=['bases', 'frequency'])
+    k_mer = math.log(len(inputfile), 4)
+    frequency = inputfile['frequency'].to_numpy()
+    MDS = np.sum(-frequency * np.log2(frequency) / np.log2(4 ** k_mer))
+    with open(outputfile, 'a') as f:
+        f.write(inputEndMotifFile + '\t' + str(MDS) + '\n')
+
+def get_Breakpoint_motif(Bpmotif, seq1, seq2):
+    # seq1 and seq2 do not include N
+    if seq1.count('N') + seq1.count('n') + seq2.count('N') + seq2.count('n') != 0:
+        return Bpmotif
+    seq2 = reverse_seq(seq2)
+    if seq1 in Bpmotif.keys():
+        Bpmotif[seq1] += 1
+    if seq2 in Bpmotif.keys():
+        Bpmotif[seq2] += 1
+    return Bpmotif

krewlyzer/motif.py

@@ -0,0 +1,275 @@
+# motif.py: Extracts motif-based features from BAM files
+import typer
+from pathlib import Path
+from typing import Optional
+import os
+import pysam
+import numpy as np
+import pandas as pd
+import math
+import pybedtools
+from collections import defaultdict
+from .helpers import (
+    reverse_seq,
+    get_End_motif,
+    get_Breakpoint_motif,
+    GCcontent,
+    read_pair_generator,
+    maxCore,
+    rmEndString,
+    calc_MDS
+)
+from rich.progress import Progress
+from rich.console import Console
+from rich.logging import RichHandler
+import logging
+
+console = Console()
+logging.basicConfig(level="INFO", handlers=[RichHandler(console=console)], format="%(message)s")
+logger = logging.getLogger("motif")
+
+
+def motif(
+    bam_path: Path = typer.Argument(..., help="Path to input BAM file or directory of BAM files (GRCh37 aligned)"),
+    genome_reference: Path = typer.Option(..., '-g', help="Path to genome reference file (GRCh37/hg19)"),
+    output: Path = typer.Option(..., '-o', help="Output directory"),
+    blacklist: Optional[Path] = typer.Option(None, '-b', help="Path to blacklist regions file"),
+    map_quality: int = typer.Option(20, '-m', help="Minimum mapping quality"),
+    min_length: int = typer.Option(65, '--minlen', help="Minimum fragment length"),
+    max_length: int = typer.Option(400, '--maxlen', help="Maximum fragment length"),
+    kmer: int = typer.Option(3, '-k', help="K-mer size for motif extraction"),
+    chromosomes: Optional[str] = typer.Option(None, '--chromosomes', help="Comma-separated list of chromosomes to process"),
+    verbose: bool = typer.Option(False, '--verbose', help="Enable verbose logging"),
+    threads: int = typer.Option(1, '--threads', help="Number of parallel processes (default: 1)")
+):
+    """
+    Extract motif-based features from BAM files.
+    """
+    # Input checks
+    if not bam_path.exists():
+        logger.error(f"Input BAM file or directory not found: {bam_path}")
+        raise typer.Exit(1)
+    if not genome_reference.exists() or not genome_reference.is_file():
+        logger.error(f"Reference genome file not found: {genome_reference}")
+        raise typer.Exit(1)
+    try:
+        output.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        logger.error(f"Could not create output directory {output}: {e}")
+        raise typer.Exit(1)
+    """
+    Extracts end motif, breakpoint motif, and Motif-Diversity Score (MDS) from one or more BAM files.
+    If a directory is provided, all BAM files in the directory will be processed in parallel using multiple processes.
+    Output files are written to the output directory, with EDM, BPM, and MDS subfolders.
+    """
+    import concurrent.futures
+    if verbose:
+        logger.setLevel(logging.DEBUG)
+    logger.info(f"Reference genome: {genome_reference}")
+    logger.info(f"Output directory: {output}")
+    if bam_path.is_dir():
+        bam_files = sorted([f for f in bam_path.iterdir() if f.suffix == '.bam'])
+        if not bam_files:
+            logger.error(f"No BAM files found in directory: {bam_path}")
+            raise typer.Exit(1)
+        logger.info(f"Processing {len(bam_files)} BAM files in parallel using {threads} processes...")
+        def run_motif_for_bam(bam_file):
+            logger.info(f"Processing BAM: {bam_file}")
+            motif_process(
+                str(bam_file),
+                str(blacklist) if blacklist else None,
+                str(output / (bam_file.stem + '.bed')),
+                str(genome_reference),
+                chromosomes.split(',') if chromosomes else None,
+                map_quality,
+                kmer,
+                fragFilter=True,
+                minLen=min_length,
+                maxLen=max_length
+            )
+            return str(bam_file)
+        with concurrent.futures.ProcessPoolExecutor(max_workers=threads) as executor:
+            futures = {executor.submit(run_motif_for_bam, bam_file): bam_file for bam_file in bam_files}
+            for future in concurrent.futures.as_completed(futures):
+                bam_file = futures[future]
+                try:
+                    result = future.result()
+                    logger.info(f"Motif extraction complete for: {result}")
+                except Exception as exc:
+                    logger.error(f"Motif extraction failed for {bam_file}: {exc}")
+        logger.info(f"All BAM files processed.")
+    else:
+        logger.info(f"Processing BAM: {bam_path}")
+        motif_process(
+            str(bam_path),
+            str(blacklist) if blacklist else None,
+            str(output / (bam_path.stem + '.bed')),
+            str(genome_reference),
+            chromosomes.split(',') if chromosomes else None,
+            map_quality,
+            kmer,
+            fragFilter=True,
+            minLen=min_length,
+            maxLen=max_length
+        )
+        logger.info("End motif, Breakpoint motif, and MDS extraction complete.")
+
+
+def motif_process(
+    bamInput,
+    blacklistInput,
+    bedOutput,
+    genome_reference,
+    CHR,
+    mapQuality,
+    k_mer,
+    fragFilter=False,
+    minLen=None,
+    maxLen=None
+):
+    """
+    Main motif feature extraction process with rich logging and consistent CLI output.
+    """
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich.text import Text
+    bedOutput_path = os.path.abspath(bedOutput)
+    EDM_output_path = os.path.join(os.path.dirname(bedOutput_path), 'EDM')
+    BPM_output_path = os.path.join(os.path.dirname(bedOutput_path), 'BPM')
+    MDS_output_path = os.path.join(os.path.dirname(bedOutput_path), 'MDS')
+    try:
+        os.makedirs(EDM_output_path, exist_ok=True)
+        os.makedirs(BPM_output_path, exist_ok=True)
+        os.makedirs(MDS_output_path, exist_ok=True)
+    except Exception as e:
+        logger.error(f"Failed to create output directories: {e}")
+        raise typer.Exit(1)
+    bases = ['A', 'C', 'T', 'G']
+    End_motif = {''.join(i): 0 for i in itertools.product(bases, repeat=k_mer)}
+    Breakpoint_motif = {''.join(i): 0 for i in itertools.product(bases, repeat=k_mer)}
+    try:
+        bamfile = pysam.AlignmentFile(bamInput, 'rb')
+    except Exception as e:
+        logger.error(f"Failed to open BAM file: {e}")
+        raise typer.Exit(1)
+    try:
+        genome = pysam.FastaFile(genome_reference)
+    except Exception as e:
+        logger.error(f"Failed to open genome FASTA: {e}")
+        raise typer.Exit(1)
+    temp_bed = bedOutput + '.tmp'
+    try:
+        bedWrite = open(temp_bed, 'w')
+    except Exception as e:
+        logger.error(f"Failed to open temp BED for writing: {e}")
+        raise typer.Exit(1)
+    chroms = CHR if CHR else list(bamfile.references)
+    logger.info("Extracting motif features from BAM file...")
+    total_pairs = bamfile.mapped // 2 if bamfile.mapped else 1000000
+    motif_errors = 0
+    with Progress(console=console, transient=True) as progress:
+        task = progress.add_task("Processing fragments", total=total_pairs)
+        for idx, pair in enumerate(read_pair_generator(bamfile)):
+            try:
+                read1, read2 = pair
+                if read1.mapping_quality < mapQuality or read2.mapping_quality < mapQuality or read1.reference_name not in chroms:
+                    continue
+                read1Start = read1.reference_start
+                read1End = read1.reference_end
+                read2Start = read2.reference_start
+                read2End = read2.reference_end
+                if not read1.is_reverse:
+                    rstart = read1Start
+                    rend = read2End
+                    forward_end5 = read1.query_sequence[:k_mer].upper()
+                    forward_end3 = read2.query_sequence[-k_mer:].upper()
+                else:
+                    rstart = read2Start
+                    rend = read1End
+                    forward_end5 = read2.query_sequence[:k_mer].upper()
+                    forward_end3 = read1.query_sequence[-k_mer:].upper()
+                if (rstart < 0) or (rend < 0) or (rstart >= rend):
+                    continue
+                if fragFilter:
+                    readLen = rend - rstart
+                    if (minLen and readLen < minLen) or (maxLen and readLen > maxLen):
+                        continue
+                gc = GCcontent(genome.fetch(read1.reference_name, rstart, rend))
+                bedWrite.write(f"{read1.reference_name}\t{rstart+1}\t{rend+1}\t{gc}\n")
+                End_motif = get_End_motif(End_motif, forward_end3, forward_end3)
+                pos = math.ceil(k_mer / 2)
+                try:
+                    if k_mer % 2 == 0:
+                        ref_seq1 = genome.fetch(read1.reference_name, rstart - pos, rstart).upper()
+                        ref_seq2 = genome.fetch(read2.reference_name, rend, rend + pos).upper()
+                        Breakpoint_motif = get_Breakpoint_motif(Breakpoint_motif, ref_seq1 + forward_end5[:pos], forward_end3[-pos:] + ref_seq2)
+                    else:
+                        ref_seq1 = genome.fetch(read1.reference_name, rstart - pos + 1, rstart).upper()
+                        ref_seq2 = genome.fetch(read2.reference_name, rend, rend + pos - 1).upper()
+                        Breakpoint_motif = get_Breakpoint_motif(Breakpoint_motif, ref_seq1 + forward_end5[:pos], forward_end3[-pos:] + ref_seq2)
+                except Exception as e:
+                    motif_errors += 1
+                    logger.warning(f"Motif extraction failed for fragment at {read1.reference_name}:{rstart}-{rend}: {e}")
+                    continue
+                if idx % 10000 == 0:
+                    progress.update(task, advance=10000)
+            except Exception as e:
+                motif_errors += 1
+                logger.error(f"Unexpected error during fragment processing: {e}")
+                continue
+        progress.update(task, completed=total_pairs)
+    bedWrite.close()
+    logger.info("Filtering and sorting fragments with blacklist (if provided)...")
+    try:
+        bedData = pybedtools.BedTool(temp_bed)
+        if blacklistInput:
+            black_reigon = pybedtools.BedTool(blacklistInput)
+            bedData = bedData.subtract(black_reigon, A=True)
+        bedData.sort(output=bedOutput)
+        os.remove(temp_bed)
+    except Exception as e:
+        logger.error(f"Error during BED filtering/sorting: {e}")
+        raise typer.Exit(1)
+    # Write EndMotif
+    edm_file = os.path.join(EDM_output_path, Path(bedOutput).stem + '.EndMotif')
+    logger.info(f"Writing End Motif frequencies to {edm_file}")
+    try:
+        with open(edm_file, 'w') as f:
+            total = sum(End_motif.values())
+            for k, v in End_motif.items():
+                f.write(f"{k}\t{v/total if total else 0}\n")
+    except Exception as e:
+        logger.error(f"Failed to write End Motif output: {e}")
+        raise typer.Exit(1)
+    # Write BreakPointMotif
+    bpm_file = os.path.join(BPM_output_path, Path(bedOutput).stem + '.BreakPointMotif')
+    logger.info(f"Writing Breakpoint Motif frequencies to {bpm_file}")
+    try:
+        with open(bpm_file, 'w') as f:
+            total = sum(Breakpoint_motif.values())
+            for k, v in Breakpoint_motif.items():
+                f.write(f"{k}\t{v/total if total else 0}\n")
+    except Exception as e:
+        logger.error(f"Failed to write Breakpoint Motif output: {e}")
+        raise typer.Exit(1)
+    # Write MDS (Motif Diversity Score)
+    mds_file = os.path.join(MDS_output_path, Path(bedOutput).stem + '.MDS')
+    logger.info(f"Writing Motif Diversity Score to {mds_file}")
+    try:
+        df = pd.read_csv(edm_file, sep='\t', header=None, names=['motif', 'frequency'])
+        freq = df['frequency'].values
+        mds = -np.sum(freq * np.log2(freq + 1e-12)) / np.log2(len(freq))
+        with open(mds_file, 'w') as f:
+            f.write(f"{mds}\n")
+    except Exception as e:
+        logger.error(f"Failed to write MDS output: {e}")
+        raise typer.Exit(1)
+    # Print summary
+    summary_table = Table(title="Motif Extraction Summary", show_header=True, header_style="bold magenta")
+    summary_table.add_column("Output Type", style="bold")
+    summary_table.add_column("File Path")
+    summary_table.add_row("End Motif (EDM)", edm_file)
+    summary_table.add_row("Breakpoint Motif (BPM)", bpm_file)
+    summary_table.add_row("Motif Diversity Score (MDS)", mds_file)
+    console.print(Panel(summary_table, title="[green]Extraction Complete", subtitle=f"Motif errors: {motif_errors}", expand=False))
+    logger.info("Motif feature extraction complete.")