krewlyzer 0.1.0__py3-none-any.whl

krewlyzer/ocf.py

@@ -0,0 +1,133 @@
+import typer
+from pathlib import Path
+from typing import Optional
+import logging
+import pysam
+import pandas as pd
+from collections import defaultdict
+from functools import partial
+from rich.console import Console
+from rich.logging import RichHandler
+from concurrent.futures import ProcessPoolExecutor, as_completed
+import os
+
+console = Console()
+logging.basicConfig(level="INFO", handlers=[RichHandler(console=console)], format="%(message)s")
+logger = logging.getLogger("ocf")
+
+
+def calc_ocf(bedgz_file: Path, ocr_file: Path, output_dir: Path):
+    """
+    Calculate OCF for a single .bed.gz file and OCR region file.
+    Output is per-region .sync.end files and a summary all.ocf.csv.
+    """
+    try:
+        tbx = pysam.TabixFile(str(bedgz_file))
+        regions = pd.read_csv(ocr_file, sep="\t", header=None, names=["chr", "start", "end", "description"])
+        leftPOS = defaultdict(partial(defaultdict, int))
+        rightPOS = defaultdict(partial(defaultdict, int))
+        total = defaultdict(lambda: [0, 0])
+        for _, region in regions.iterrows():
+            region_Chr, region_Start, region_End, region_Label = (
+                region["chr"], region["start"], region["end"], region["description"])
+            try:
+                fetched_reads = tbx.fetch(region_Chr, region_Start, region_End)
+            except ValueError:
+                continue
+            for row in fetched_reads:
+                tmp_row = row.split()
+                rstart = int(tmp_row[1])
+                rend = int(tmp_row[2])
+                if rstart >= region_Start:
+                    s = rstart - region_Start
+                    leftPOS[region_Label][s] += 1
+                    total[region_Label][0] += 1
+                if rend <= region_End:
+                    e = rend - region_Start + 1
+                    rightPOS[region_Label][e] += 1
+                    total[region_Label][1] += 1
+        Labels = []
+        ocf = []
+        outputfile = output_dir / 'all.ocf.csv'
+        for label in total.keys():
+            output = output_dir / f'{label}.sync.end'
+            Labels.append(label)
+            le = leftPOS[label]
+            re = rightPOS[label]
+            ts = total[label][0] / 10000 if total[label][0] else 1
+            te = total[label][1] / 10000 if total[label][1] else 1
+            num = 2000
+            with open(output, 'w') as output_write:
+                for k in range(num):
+                    l = le[k]
+                    r = re[k]
+                    output_write.write(
+                        f"{k - 1000}\t{l}\t{l / ts}\t{r}\t{r / te}\n")
+            # OCF calculation
+            with open(output, 'r') as o:
+                peak = 60
+                bin = 10
+                trueends = 0
+                background = 0
+                for line in o.readlines():
+                    loc, left, Left, right, Right = line.split()
+                    loc = int(loc)
+                    if -peak - bin <= loc <= -peak + bin:
+                        trueends += float(Right)
+                        background += float(Left)
+                    elif peak - bin <= loc <= peak + bin:
+                        trueends += float(Left)
+                        background += float(Right)
+                ocf.append(trueends - background)
+        import pandas as pd
+        ocf_df = pd.DataFrame({"tissue": Labels, "OCF": ocf})
+        ocf_df.to_csv(outputfile, sep="\t", index=None)
+        logger.info(f"OCF calculation complete for {bedgz_file}. Results in {output_dir}.")
+    except Exception as e:
+        logger.error(f"Fatal error in calc_ocf: {e}")
+        raise typer.Exit(1)
+
+
+def ocf(
+    bedgz_path: Path = typer.Argument(..., help="Folder containing .bed.gz files (should be the output directory from motif.py)"),
+    ocr_input: Optional[Path] = typer.Option(None, "--ocr-input", "-r", help="Path to open chromatin region BED file (default: packaged tissue file)"),
+    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 orientation-aware cfDNA fragmentation (OCF) 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 ocr_input and not ocr_input.exists():
+        logger.error(f"OCR region BED file not found: {ocr_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)
+    # Set default OCR file if not provided
+    if ocr_input is None:
+        pkg_dir = Path(__file__).parent
+        ocr_input = pkg_dir / "data/OpenChromatinRegion/7specificTissue.all.OC.bed"
+    bedgz_files = [f for f in Path(bedgz_path).glob("*.bed.gz")]
+    output = Path(output)
+    output.mkdir(parents=True, exist_ok=True)
+    def run_ocf_file(bedgz_file):
+        sample_dir = output / bedgz_file.stem.replace('.bed', '')
+        sample_dir.mkdir(exist_ok=True)
+        calc_ocf(bedgz_file, ocr_input, sample_dir)
+        return str(sample_dir)
+    with ProcessPoolExecutor(max_workers=threads) as executor:
+        futures = {executor.submit(run_ocf_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"OCF calculated: {result}")
+            except Exception as exc:
+                logger.error(f"OCF calculation failed for {bedgz_file}: {exc}")
+    logger.info(f"OCF features calculated for {len(bedgz_files)} files.")

krewlyzer/uxm.py

@@ -0,0 +1,188 @@
+import typer
+from pathlib import Path
+from typing import Optional
+import logging
+import pysam
+import pybedtools
+import numpy as np
+from rich.console import Console
+from rich.logging import RichHandler
+from concurrent.futures import ProcessPoolExecutor, as_completed
+import os
+
+console = Console()
+logging.basicConfig(level="INFO", handlers=[RichHandler(console=console)], format="%(message)s")
+logger = logging.getLogger("uxm")
+
+def calc_uxm(
+    bam_file: Path,
+    mark_file: Path,
+    output_file: Path,
+    map_quality: int,
+    min_cpg: int,
+    methy_threshold: float,
+    unmethy_threshold: float,
+    pe_type: str = "PE"
+):
+    """
+    Calculate UXM fragment-level methylation for a single BAM and marker file.
+    Output is a .UXM.tsv file with region, U, X, M proportions.
+    """
+    try:
+        bai = str(bam_file) + ".bai"
+        if not os.path.exists(bai):
+            pysam.sort("-o", str(bam_file), str(bam_file))
+            pysam.index(str(bam_file))
+            logger.warning(f"Index file {bai} did not exist. Sorted and indexed BAM.")
+        input_file = pysam.AlignmentFile(str(bam_file))
+        marks = pybedtools.BedTool(str(mark_file))
+        res = []
+        for mark in marks:
+            region = f"{mark.chrom}:{mark.start}-{mark.end}"
+            try:
+                input_file.fetch(mark.chrom, mark.start, mark.end)
+            except ValueError:
+                res.append(f"{region}\t0\t0\t0")
+                continue
+            Ufragment = 0
+            Xfragment = 0
+            Mfragment = 0
+            if pe_type == "PE":
+                from krewlyzer.helpers import read_pair_generator
+                region_string = f"{mark.chrom}:{mark.start}-{mark.end}"
+                for read1, read2 in read_pair_generator(input_file, region_string):
+                    if read1 is None or read2 is None:
+                        continue
+                    if read1.mapping_quality < map_quality or read2.mapping_quality < map_quality:
+                        continue
+                    try:
+                        m1 = read1.get_tag("XM")
+                        m2 = read2.get_tag("XM")
+                    except KeyError:
+                        continue
+                    read1Start = read1.reference_start
+                    read1End = read1.reference_end
+                    read2Start = read2.reference_start
+                    read2End = read2.reference_end
+                    # cfDNAFE logic for overlap
+                    if not read1.is_reverse:  # read1 is forward, read2 is reverse
+                        if read2Start < read1End:
+                            overlap = read1End - read2Start
+                            num_methylated = m1.count("Z") + m2[overlap:].count("Z")
+                            num_unmethylated = m1.count("z") + m2[overlap:].count("z")
+                        else:
+                            num_methylated = m1.count("Z") + m2.count("Z")
+                            num_unmethylated = m1.count("z") + m2.count("z")
+                    else:  # read1 is reverse, read2 is forward
+                        if read1Start < read2End:
+                            overlap = read2End - read1Start
+                            num_methylated = m2.count("Z") + m1[overlap:].count("Z")
+                            num_unmethylated = m2.count("z") + m1[overlap:].count("z")
+                        else:
+                            num_methylated = m1.count("Z") + m2.count("Z")
+                            num_unmethylated = m1.count("z") + m2.count("z")
+                    if num_methylated + num_unmethylated < min_cpg:
+                        continue
+                    ratio = num_methylated / (num_methylated + num_unmethylated)
+                    if ratio >= methy_threshold:
+                        Mfragment += 1
+                    elif ratio <= unmethy_threshold:
+                        Ufragment += 1
+                    else:
+                        Xfragment += 1
+            elif pe_type == "SE":
+                for read in input_file.fetch(mark.chrom, mark.start, mark.end):
+                    if read.mapping_quality < map_quality:
+                        continue
+                    try:
+                        m = read.get_tag("XM")
+                    except KeyError:
+                        continue
+                    num_methylated = m.count("Z")
+                    num_unmethylated = m.count("z")
+                    if num_methylated + num_unmethylated < min_cpg:
+                        continue
+                    ratio = num_methylated / (num_methylated + num_unmethylated)
+                    if ratio >= methy_threshold:
+                        Mfragment += 1
+                    elif ratio <= unmethy_threshold:
+                        Ufragment += 1
+                    else:
+                        Xfragment += 1
+            else:
+                logger.error("type must be SE or PE")
+                raise typer.Exit(1)
+            total = Mfragment + Ufragment + Xfragment
+            if total == 0:
+                res.append(f"{region}\t0\t0\t0")
+            else:
+                tmp_array = np.zeros(3)
+                tmp_array[0] = Ufragment / total
+                tmp_array[1] = Xfragment / total
+                tmp_array[2] = Mfragment / total
+                res.append(f"{region}\t" + "\t".join(map(str, tmp_array)))
+        with open(output_file, 'w') as f:
+            f.write('region\tU\tX\tM\n')
+            for i in res:
+                f.write(i + '\n')
+        logger.info(f"UXM calculation complete for {bam_file}. Results in {output_file}.")
+    except Exception as e:
+        logger.error(f"Fatal error in calc_uxm: {e}")
+        raise typer.Exit(1)
+
+def uxm(
+    bam_path: Path = typer.Argument(..., help="Folder containing .bam files for UXM calculation."),
+    mark_input: Optional[Path] = typer.Option(None, "--mark-input", "-m", help="Marker BED file (default: packaged atlas)", show_default=False),
+    output: Path = typer.Option(..., "--output", "-o", help="Output folder for results"),
+    map_quality: int = typer.Option(30, "--map-quality", "-q", help="Minimum mapping quality"),
+    min_cpg: int = typer.Option(4, "--min-cpg", "-c", help="Minimum CpG count per fragment"),
+    methy_threshold: float = typer.Option(0.75, "--methy-threshold", "-tM", help="Methylation threshold for M fragments"),
+    unmethy_threshold: float = typer.Option(0.25, "--unmethy-threshold", "-tU", help="Unmethylation threshold for U fragments"),
+    pe_type: str = typer.Option("SE", "--type", help="Fragment type: SE or PE (default: SE)"),
+    threads: int = typer.Option(1, "--threads", "-t", help="Number of parallel processes (default: 1)")
+):
+    """
+    Calculate fragment-level methylation (UXM) features for all BAM files in a folder.
+    """
+    # Input checks
+    if not bam_path.exists():
+        logger.error(f"Input BAM directory not found: {bam_path}")
+        raise typer.Exit(1)
+    if mark_input and not mark_input.exists():
+        logger.error(f"Marker BED file not found: {mark_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)
+    if mark_input is None:
+        pkg_dir = Path(__file__).parent
+        mark_input = pkg_dir / "data/MethMark/Atlas.U25.l4.hg19.bed"
+    bam_files = [f for f in Path(bam_path).glob("*.bam")]
+    output = Path(output)
+    output.mkdir(parents=True, exist_ok=True)
+    def run_uxm_file(bam_file):
+        sample_prefix = bam_file.stem.replace('.bam', '')
+        output_file = output / f"{sample_prefix}.UXM.tsv"
+        calc_uxm(
+            bam_file,
+            mark_input,
+            output_file,
+            map_quality,
+            min_cpg,
+            methy_threshold,
+            unmethy_threshold,
+            pe_type
+        )
+        return str(output_file)
+    with ProcessPoolExecutor(max_workers=threads) as executor:
+        futures = {executor.submit(run_uxm_file, bam_file): bam_file for bam_file in bam_files}
+        for future in as_completed(futures):
+            bam_file = futures[future]
+            try:
+                result = future.result()
+                logger.info(f"UXM calculated: {result}")
+            except Exception as exc:
+                logger.error(f"UXM calculation failed for {bam_file}: {exc}")
+    logger.info(f"UXM features calculated for {len(bam_files)} files.")

krewlyzer/wps.py

@@ -0,0 +1,173 @@
+import typer
+from pathlib import Path
+import logging
+import pysam
+import pybedtools
+import numpy as np
+from collections import defaultdict
+import gzip
+from rich.console import Console
+from rich.logging import RichHandler
+
+from .helpers import max_core, commonError
+
+console = Console()
+logging.basicConfig(level="INFO", handlers=[RichHandler(console=console)], format="%(message)s")
+logger = logging.getLogger("wps")
+
+
+def _calc_wps(bedgz_input, tsv_input, output_file_pattern, empty=False, protect_input=120, min_size=120, max_size=180):
+    """
+    Calculate Windowed Protection Score (WPS) for a single .bed.gz file and transcript region file.
+    Output is gzipped TSV per region.
+    """
+    try:
+        bedgzfile = str(bedgz_input)
+        tbx = pysam.TabixFile(bedgzfile)
+        protection = protect_input // 2
+        with open(tsv_input, 'r') as infile:
+            prefix = "chr"
+            valid_chroms = set(map(str, list(range(1, 23)) + ["X"]))
+            logger.info(f"input file: {bedgz_input}, {tsv_input}")
+            for line in infile:
+                if not line.strip():
+                    continue
+                parts = line.split()
+                if len(parts) < 5:
+                    continue
+                cid, chrom, start, end, strand = parts[:5]
+                chrom = chrom.replace("chr", "")
+                if chrom not in valid_chroms:
+                    continue
+                region_start, region_end = int(float(start)), int(float(end))
+                if region_start < 1:
+                    continue
+                pos_range = defaultdict(lambda: [0, 0])
+                try:
+                    from bx.intervals.intersection import Intersecter, Interval
+                    filtered_reads = Intersecter()
+                    for row in tbx.fetch(prefix + chrom, region_start - protection, region_end + protection):
+                        tmp_row = row.split()
+                        rstart = int(tmp_row[1])
+                        rend = int(tmp_row[2])
+                        lseq = rend - rstart
+                        if lseq < min_size or lseq > max_size:
+                            continue
+                        filtered_reads.add_interval(Interval(rstart, rend))
+                        for i in range(rstart, rend):
+                            if region_start <= i <= region_end:
+                                pos_range[i][0] += 1
+                        if region_start <= rstart <= region_end:
+                            pos_range[rstart][1] += 1
+                        if region_start <= rend <= region_end:
+                            pos_range[rend][1] += 1
+                except Exception as e:
+                    logger.error(f"Error fetching region {chrom}:{region_start}-{region_end}: {e}")
+                    continue
+                filename = output_file_pattern % cid
+                with gzip.open(filename, 'wt') as outfile:
+                    cov_sites = 0
+                    out_lines = []
+                    for pos in range(region_start, region_end + 1):
+                        rstart, rend = pos - protection, pos + protection
+                        gcount, bcount = 0, 0
+                        for read in filtered_reads.find(rstart, rend):
+                            if (read.start > rstart) or (read.end < rend):
+                                bcount += 1
+                            else:
+                                gcount += 1
+                        cov_count, start_count = pos_range[pos]
+                        cov_sites += cov_count
+                        out_lines.append(f"{chrom}\t{pos}\t{cov_count}\t{start_count}\t{gcount - bcount}\n")
+                    if strand == "-":
+                        out_lines = out_lines[::-1]
+                    for line in out_lines:
+                        outfile.write(line)
+                if cov_sites == 0 and not empty:
+                    import os
+                    os.remove(filename)
+        logger.info(f"WPS calculation complete. Results written to pattern: {output_file_pattern}")
+    except Exception as e:
+        logger.error(f"Fatal error in _calc_wps: {e}")
+        raise typer.Exit(1)
+
+
+def wps(
+    bedgz_path: Path = typer.Argument(..., help="Folder containing .bed.gz files (should be the output directory from motif.py)"),
+    tsv_input: Path = typer.Option(None, "--tsv-input", "-t", help="Path to transcript/region file (TSV format)"),
+    output: Path = typer.Option(..., "--output", "-o", help="Output folder for results"),
+    wpstype: str = typer.Option('L', "--wpstype", "-w", help="WPS type: 'L' for long (default), 'S' for short"),
+    empty: bool = typer.Option(False, "--empty", help="Keep files of empty blocks (default: False)"),
+    threads: int = typer.Option(1, "--threads", "-p", help="Number of threads (default: 1)")
+):
+    """
+    Calculate Windowed Protection Score (WPS) 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 tsv_input and not tsv_input.exists():
+        logger.error(f"Transcript region file not found: {tsv_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)
+    try:
+        output.touch()
+    except Exception as e:
+        logger.error(f"Output directory {output} is not writable: {e}")
+        raise typer.Exit(1)
+    try:
+        bedgz_files = list(Path(bedgz_path).glob("*.bed.gz"))
+        if not bedgz_files:
+            logger.error("No .bed.gz files found in the specified folder.")
+            raise typer.Exit(1)
+        if tsv_input is None:
+            # Default to package data transcriptAnno-hg19-1kb.tsv
+            tsv_input = Path(__file__).parent.parent / "data" / "TranscriptAnno" / "transcriptAnno-hg19-1kb.tsv"
+            logger.info(f"No tsv_input specified. Using default: {tsv_input}")
+        if not tsv_input.exists():
+            logger.error(f"Transcript/region file does not exist: {tsv_input}")
+            raise typer.Exit(1)
+        if wpstype == 'L':
+            protect_input = 120
+            min_size = 120
+            max_size = 180
+        else:
+            protect_input = 16
+            min_size = 35
+            max_size = 80
+        output.mkdir(parents=True, exist_ok=True)
+        logger.info(f"Calculating WPS for {len(bedgz_files)} files...")
+        from concurrent.futures import ProcessPoolExecutor, as_completed
+        import traceback
+        def wps_task(bedgz_file):
+            try:
+                output_file_pattern = str(output / (bedgz_file.stem.replace('.bed', '') + ".%s.WPS.tsv.gz"))
+                _calc_wps(
+                    bedgz_input=str(bedgz_file),
+                    tsv_input=str(tsv_input),
+                    output_file_pattern=output_file_pattern,
+                    empty=empty,
+                    protect_input=protect_input,
+                    min_size=min_size,
+                    max_size=max_size
+                )
+                return None
+            except Exception as exc:
+                return traceback.format_exc()
+        n_procs = max_core(threads) if threads else 1
+        logger.info(f"Calculating WPS for {len(bedgz_files)} files using {n_procs} processes...")
+        with ProcessPoolExecutor(max_workers=n_procs) as executor:
+            futures = {executor.submit(wps_task, bedgz_file): bedgz_file for bedgz_file in bedgz_files}
+            for future in as_completed(futures):
+                exc = future.result()
+                if exc:
+                    logger.error(f"WPS calculation failed for {futures[future]}:\n{exc}")
+        logger.info(f"WPS features calculated for {len(bedgz_files)} files.")
+    except Exception as e:
+        logger.error(f"Fatal error in wps CLI: {e}")
+        raise typer.Exit(1)

krewlyzer/wrapper.py

@@ -0,0 +1,125 @@
+import typer
+from pathlib import Path
+import logging
+from rich.console import Console
+from rich.logging import RichHandler
+from .motif import motif
+from .fsc import fsc
+from .fsr import fsr
+from .fsd import fsd
+from .wps import wps
+from .ocf import ocf
+from .uxm import uxm
+
+console = Console()
+logging.basicConfig(level="INFO", handlers=[RichHandler(console=console)], format="%(message)s")
+logger = logging.getLogger("krewlyzer-wrapper")
+
+
+def run_all(
+    bam_file: Path = typer.Argument(..., help="Input BAM file (sorted, indexed)"),
+    reference: Path = typer.Option(..., "--reference", "-g", help="Reference genome FASTA file for motif extraction"),
+    output: Path = typer.Option(..., "--output", "-o", help="Output directory for all results"),
+    threads: int = typer.Option(1, "--threads", "-t", help="Number of parallel processes for each step"),
+    pe_type: str = typer.Option("SE", "--type", help="Fragment type for UXM: SE or PE (default: SE)")
+):
+    """
+    Run all feature extraction commands (motif, fsc, fsr, fsd, wps, ocf, uxm) for a single BAM file.
+    """
+    # Input checks
+    if not bam_file.exists() or not bam_file.is_file():
+        logger.error(f"Input BAM file not found: {bam_file}")
+        raise typer.Exit(1)
+    if not reference.exists() or not reference.is_file():
+        logger.error(f"Reference FASTA file not found: {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)
+    # 1. Motif extraction
+    motif_output = output / "motif"
+    try:
+        motif(
+            bam_path=bam_file,
+            reference=reference,
+            output=motif_output,
+            minlen=65,
+            maxlen=400,
+            k=3,
+            verbose=True,
+            threads=threads,
+        )
+    except Exception as e:
+        logger.error(f"Motif extraction failed: {e}")
+        raise typer.Exit(1)
+    # 2. FSC
+    fsc_output = output / "fsc"
+    try:
+        fsc(
+            bedgz_path=motif_output,
+            output=fsc_output,
+            threads=threads
+        )
+    except Exception as e:
+        logger.error(f"FSC calculation failed: {e}")
+        raise typer.Exit(1)
+    # 3. FSR
+    fsr_output = output / "fsr"
+    try:
+        fsr(
+            bedgz_path=motif_output,
+            output=fsr_output,
+            threads=threads
+        )
+    except Exception as e:
+        logger.error(f"FSR calculation failed: {e}")
+        raise typer.Exit(1)
+    # 4. FSD
+    fsd_output = output / "fsd"
+    try:
+        fsd(
+            bedgz_path=motif_output,
+            output=fsd_output,
+            arms_file=None,
+            threads=threads
+        )
+    except Exception as e:
+        logger.error(f"FSD calculation failed: {e}")
+        raise typer.Exit(1)
+    # 5. WPS
+    wps_output = output / "wps"
+    try:
+        wps(
+            bedgz_path=motif_output,
+            output=wps_output,
+            threads=threads
+        )
+    except Exception as e:
+        logger.error(f"WPS calculation failed: {e}")
+        raise typer.Exit(1)
+    # 6. OCF
+    ocf_output = output / "ocf"
+    try:
+        ocf(
+            bedgz_path=motif_output,
+            output=ocf_output,
+            threads=threads
+        )
+    except Exception as e:
+        logger.error(f"OCF calculation failed: {e}")
+        raise typer.Exit(1)
+    # 7. UXM
+    uxm_output = output / "uxm"
+    try:
+        uxm(
+            bam_path=bam_file.parent,
+            output=uxm_output,
+            pe_type=pe_type,
+            threads=threads
+        )
+    except Exception as e:
+        logger.error(f"UXM calculation failed: {e}")
+        raise typer.Exit(1)
+    logger.info(f"All feature extraction complete. Results saved to {output}")

krewlyzer-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: krewlyzer
+Version: 0.1.0
+Summary: Feature extraction tools for circulating tumor DNA from GRCh37 aligned BAM files
+Author-email: Ronak Shah <shahr2@mskcc.org>
+Project-URL: Homepage, https://github.com/msk-access/krewlyzer
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: typer>=0.12.3
+Requires-Dist: pysam>=0.20.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: biopython>=1.81
+Requires-Dist: pybedtools>=0.9.0
+Requires-Dist: scikit-misc>=0.1.4
+Dynamic: license-file

krewlyzer-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+krewlyzer/__init__.py,sha256=qpkv4AhtoRCJsN5NGxl1bc5RJo8_l-EduGL1emFww0Y,67
+krewlyzer/cli.py,sha256=MuMUiV79mcotsf73DRDtW3C0wwGhE3jcVvpfjJ3mtA0,1232
+krewlyzer/fsc.py,sha256=NfRiRFxZVVnbGMyWfrYIucz9Em4EhNnWigNdcsekPZk,21688
+krewlyzer/fsd.py,sha256=PVs_aTiitVSHtiEcmbi5ocFe0Xj8g7xmIkcgmC-vXEg,6353
+krewlyzer/fsr.py,sha256=JZg2D3AYCK2Y26SZ7mWo6U-i4zyGrKOolg5m6_DKLvw,8018
+krewlyzer/helpers.py,sha256=-FDOMIh8ANs6lC60vTq_tLrjU4OUdeuRwu1oVpBwyP8,5887
+krewlyzer/motif.py,sha256=yg0RQ2cWSmQyaEqa5VX38DECQ1sWubdi6kDose7q7bg,12490
+krewlyzer/ocf.py,sha256=4XMKjpRE1LlepFzXJcsOIAW3oP9MxQe45PAn3qpdVeA,5816
+krewlyzer/uxm.py,sha256=7ktSFAhn7pqFYwG3UmKP49Sge9Hie0HlP-70X4dcQpc,8483
+krewlyzer/wps.py,sha256=-XDVCbHYyz1uGZUNTkSgBmae8qbK6GZJFzyWFMvjQ2o,7982
+krewlyzer/wrapper.py,sha256=Gpfo-lGY_2hwpcwXN5exVjvhoec8X4wtUrF3YjgHj1A,3833
+krewlyzer-0.1.0.dist-info/licenses/LICENSE,sha256=DuJF49YfFt6g7la7cekWI06XA7ImodNiTEOrEBsOkpk,32365
+krewlyzer-0.1.0.dist-info/METADATA,sha256=RLBb0adv1Ob3XPlfbgpVQnVnS_-srP3RRKtaIy3sDr4,502
+krewlyzer-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+krewlyzer-0.1.0.dist-info/entry_points.txt,sha256=x9Wngsqelv0MxiUvgDDx3hVNR-MhDbASxwKpNeBiX8I,48
+krewlyzer-0.1.0.dist-info/top_level.txt,sha256=bFO6hK-X3pxPGZ7ewoOVx80u9p_Npyy9NW8XophctdY,10
+krewlyzer-0.1.0.dist-info/RECORD,,

krewlyzer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

krewlyzer-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+krewlyzer = krewlyzer.cli:app