krewlyzer 0.1.4__py3-none-any.whl

krewlyzer/uxm.py

@@ -0,0 +1,188 @@
+import typer
+from pathlib import Path
+from typing import Optional
+import logging
+import pysam
+
+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"
+) -> None:
+    """
+    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)")
+) -> None:
+    """
+    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,264 @@
+import typer
+from pathlib import Path
+import logging
+import pysam
+
+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")
+
+
+import pandas as pd
+
+def _calc_wps(
+    bedgz_input: str | Path, 
+    tsv_input: str | Path, 
+    output_file_pattern: str, 
+    empty: bool = False, 
+    protect_input: int = 120, 
+    min_size: int = 120, 
+    max_size: int = 180
+):
+    """
+    Calculate Windowed Protection Score (WPS) for a single .bed.gz file and transcript region file.
+    Output is gzipped TSV per region.
+    Optimized with vectorized operations.
+    """
+    try:
+        bedgzfile = str(bedgz_input)
+        tbx = pysam.TabixFile(bedgzfile)
+        protection = protect_input // 2
+        
+        logger.info(f"Processing {bedgz_input} with regions from {tsv_input}")
+        
+        with open(tsv_input, 'r') as infile:
+            valid_chroms = set(map(str, list(range(1, 23)) + ["X", "Y"]))
+            
+            for line in infile:
+                if not line.strip():
+                    continue
+                parts = line.split()
+                if len(parts) < 5:
+                    continue
+                cid, chrom, start_str, end_str, strand = parts[:5]
+                chrom = chrom.replace("chr", "")
+                if chrom not in valid_chroms:
+                    continue
+                    
+                region_start = int(float(start_str))
+                region_end = int(float(end_str))
+                
+                if region_start < 1:
+                    continue
+                    
+                # Region length (inclusive)
+                length = region_end - region_start + 1
+                
+                # Arrays for the region (0-based index relative to region_start)
+                cov_arr = np.zeros(length, dtype=int)
+                start_arr = np.zeros(length, dtype=int)
+                gcount_arr = np.zeros(length, dtype=int)
+                total_arr = np.zeros(length, dtype=int)
+                
+                # Fetch reads
+                # Pysam fetch is 0-based.
+                # Region 1-based [S, E] -> 0-based [S-1, E)
+                # We need reads extending 'protection' bp around the region
+                fetch_start = max(0, region_start - protection - 1)
+                fetch_end = region_end + protection
+                
+                # Ensure 'chr' prefix for fetching as per original logic
+                fetch_chrom = "chr" + chrom if not chrom.startswith("chr") else chrom
+                
+                try:
+                    rows = list(tbx.fetch(fetch_chrom, fetch_start, fetch_end, parser=pysam.asTuple()))
+                except ValueError:
+                    # Try without chr prefix if failed?
+                    try:
+                        rows = list(tbx.fetch(chrom, fetch_start, fetch_end, parser=pysam.asTuple()))
+                    except ValueError:
+                        rows = []
+                except Exception as e:
+                    logger.error(f"Error fetching region {chrom}:{region_start}-{region_end}: {e}")
+                    continue
+                
+                if not rows:
+                    if not empty:
+                        continue
+                
+                # Process reads
+                for row in rows:
+                    # BED is 0-based start, 0-based exclusive end
+                    rstart = int(row[1])
+                    rend = int(row[2])
+                    lseq = rend - rstart
+                    
+                    if lseq < min_size or lseq > max_size:
+                        continue
+                        
+                    # Convert read to 1-based inclusive for easier logic with 1-based regions
+                    r_start_1 = rstart + 1
+                    r_end_1 = rend
+                    
+                    # 1. Coverage (covCount)
+                    # Read spans [r_start_1, r_end_1]
+                    ov_start = max(region_start, r_start_1)
+                    ov_end = min(region_end, r_end_1)
+                    
+                    if ov_start <= ov_end:
+                        idx_start = ov_start - region_start
+                        idx_end = ov_end - region_start + 1
+                        cov_arr[idx_start:idx_end] += 1
+                        
+                    # 2. Start Count (ends)
+                    if region_start <= r_start_1 <= region_end:
+                        start_arr[r_start_1 - region_start] += 1
+                    if region_start <= r_end_1 <= region_end:
+                        start_arr[r_end_1 - region_start] += 1
+                        
+                    # 3. WPS
+                    # gcount (spanning): window [k-P, k+P] is inside read
+                    # Range: [r_start_1 + P, r_end_1 - P]
+                    g_start = r_start_1 + protection
+                    g_end = r_end_1 - protection
+                    
+                    g_ov_start = max(region_start, g_start)
+                    g_ov_end = min(region_end, g_end)
+                    
+                    if g_ov_start <= g_ov_end:
+                        idx_start = g_ov_start - region_start
+                        idx_end = g_ov_end - region_start + 1
+                        gcount_arr[idx_start:idx_end] += 1
+                        
+                    # total (overlapping): window [k-P, k+P] overlaps read
+                    # Range: [r_start_1 - P, r_end_1 + P]
+                    t_start = r_start_1 - protection
+                    t_end = r_end_1 + protection
+                    
+                    t_ov_start = max(region_start, t_start)
+                    t_ov_end = min(region_end, t_end)
+                    
+                    if t_ov_start <= t_ov_end:
+                        idx_start = t_ov_start - region_start
+                        idx_end = t_ov_end - region_start + 1
+                        total_arr[idx_start:idx_end] += 1
+                
+                # WPS = Spanning - (Total - Spanning) = 2 * Spanning - Total
+                wps_arr = 2 * gcount_arr - total_arr
+                
+                # Check if we should write
+                if np.sum(cov_arr) == 0 and not empty:
+                    continue
+                    
+                # Prepare output
+                filename = output_file_pattern % cid
+                
+                positions = np.arange(region_start, region_end + 1)
+                df = pd.DataFrame({
+                    'chrom': chrom,
+                    'pos': positions,
+                    'cov': cov_arr,
+                    'starts': start_arr,
+                    'wps': wps_arr
+                })
+                
+                if strand == "-":
+                    df = df.iloc[::-1]
+                
+                with gzip.open(filename, 'wt') as outfile:
+                    for _, row in df.iterrows():
+                        outfile.write(f"{row['chrom']}\t{int(row['pos'])}\t{int(row['cov'])}\t{int(row['starts'])}\t{int(row['wps'])}\n")
+                        
+        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,147 @@
+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
+from .mfsd import mfsd
+from typing import Optional
+
+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"),
+    variant_input: Optional[Path] = typer.Option(None, "--variant-input", "-v", help="Input VCF/MAF file for mFSD analysis"),
+    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, mfsd) 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)
+    
+    # 8. mFSD (Optional)
+    if variant_input:
+        if not variant_input.exists():
+            logger.warning(f"Variant input file not found: {variant_input}. Skipping mFSD.")
+        else:
+            mfsd_output = output / "mfsd" / (bam_file.stem + ".mfsd.tsv")
+            try:
+                mfsd(
+                    bam_path=bam_file,
+                    input_file=variant_input,
+                    output=mfsd_output,
+                    format="auto",
+                    map_quality=20
+                )
+            except Exception as e:
+                logger.error(f"mFSD calculation failed: {e}")
+                # Don't raise exit here, just log error as it's optional
+    
+    logger.info(f"All feature extraction complete. Results saved to {output}")

krewlyzer-0.1.4.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: krewlyzer
+Version: 0.1.4
+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: scikit-misc>=0.1.4
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5.0; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5.0; extra == "docs"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-mock>=3.10.0; extra == "test"
+Dynamic: license-file

krewlyzer-0.1.4.dist-info/RECORD

@@ -0,0 +1,18 @@
+krewlyzer/__init__.py,sha256=trkZFdHJ1IoLrxZb8PVQe2wSGn_ojPODNqHbjLSL1_c,90
+krewlyzer/cli.py,sha256=4a_gl59n4RguPMFsRi7OZ0-uhAfk7PFDOgFdUvD1a1A,1553
+krewlyzer/fsc.py,sha256=O3VZz-lY-s603Pq-94txL49vBSbxSMPIxOmVykUvHS8,14548
+krewlyzer/fsd.py,sha256=u91sb8WLNv6t0DBwg_SwFL-RLaWPGNb2f4LrBKzh0wQ,6857
+krewlyzer/fsr.py,sha256=ee5ZijYjUAdIvs2TVeBvmm6qQwUCp6XjenVQUSeXCBQ,9411
+krewlyzer/helpers.py,sha256=NA7YBfIRYKj_ZdjiwG96yOyd8IC03VPgBBokfj1a1_g,8540
+krewlyzer/mfsd.py,sha256=C7xAaTPSU-KOL0Mvu5nYBugfCidOVN9YWaFZmDfe0Uw,9451
+krewlyzer/motif.py,sha256=6xCocdFAn0BBssxWzXhGxHac0OHvVKRg6ovQQ-XLr_c,20610
+krewlyzer/ocf.py,sha256=cSIy8ax-EWVONarFZgvunIexbP2q39oY66R0i9Xd9-0,5832
+krewlyzer/uxm.py,sha256=LOyEXCDQimucTTwl2A95dfHJDFyKK0S6MpREpFnOVXI,8482
+krewlyzer/wps.py,sha256=7-u_VJ2kdYfvq-CSuCrCTRoRjlIRMJopB5K0jAr1G-E,11279
+krewlyzer/wrapper.py,sha256=V6BvaxlHl1z7JBMtQC1AteNrTQ9oYf2hHIleje3Cb-M,4715
+krewlyzer-0.1.4.dist-info/licenses/LICENSE,sha256=DuJF49YfFt6g7la7cekWI06XA7ImodNiTEOrEBsOkpk,32365
+krewlyzer-0.1.4.dist-info/METADATA,sha256=Za75HoZckHD7LjPZmbrzI3lckh0YPFztei4E4R9uxiI,767
+krewlyzer-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+krewlyzer-0.1.4.dist-info/entry_points.txt,sha256=x9Wngsqelv0MxiUvgDDx3hVNR-MhDbASxwKpNeBiX8I,48
+krewlyzer-0.1.4.dist-info/top_level.txt,sha256=bFO6hK-X3pxPGZ7ewoOVx80u9p_Npyy9NW8XophctdY,10
+krewlyzer-0.1.4.dist-info/RECORD,,

krewlyzer-0.1.4.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.4.dist-info/entry_points.txt

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