smftools 0.1.6__py3-none-any.whl → 0.2.1__py3-none-any.whl

smftools/informatics/helpers/discover_input_files.py

@@ -0,0 +1,100 @@
+from pathlib import Path
+from typing import Dict, List, Any, Tuple
+
+def discover_input_files(
+    input_data_path: str,
+    bam_suffix: str = ".bam",
+    recursive: bool = False,
+    follow_symlinks: bool = False,
+) -> Dict[str, Any]:
+    """
+    Discover input files under `input_data_path`.
+
+    Returns a dict with:
+      - pod5_paths, fast5_paths, fastq_paths, bam_paths (lists of str)
+      - input_is_pod5, input_is_fast5, input_is_fastq, input_is_bam (bools)
+      - all_files_searched (int)
+    Behavior:
+      - If `input_data_path` is a file, returns that single file categorized.
+      - If it is a directory, scans either immediate children (recursive=False)
+        or entire tree (recursive=True). Uses Path.suffixes to detect .fastq.gz etc.
+    """
+    p = Path(input_data_path)
+    pod5_exts = {".pod5", ".p5"}
+    fast5_exts = {".fast5", ".f5"}
+    fastq_exts = {".fastq", ".fq", ".fastq.gz", ".fq.gz", ".fastq.xz", ".fq.xz"}
+    # normalize bam suffix with leading dot
+    if not bam_suffix.startswith("."):
+        bam_suffix = "." + bam_suffix
+    bam_suffix = bam_suffix.lower()
+
+    pod5_paths: List[str] = []
+    fast5_paths: List[str] = []
+    fastq_paths: List[str] = []
+    bam_paths: List[str] = []
+    other_paths: List[str] = []
+
+    def _file_ext_key(pp: Path) -> str:
+        # join suffixes to handle .fastq.gz
+        return "".join(pp.suffixes).lower() if pp.suffixes else pp.suffix.lower()
+
+    if p.exists() and p.is_file():
+        ext_key = _file_ext_key(p)
+        if ext_key in pod5_exts:
+            pod5_paths.append(str(p))
+        elif ext_key in fast5_exts:
+            fast5_paths.append(str(p))
+        elif ext_key in fastq_exts:
+            fastq_paths.append(str(p))
+        elif ext_key == bam_suffix:
+            bam_paths.append(str(p))
+        else:
+            other_paths.append(str(p))
+        total_searched = 1
+    elif p.exists() and p.is_dir():
+        if recursive:
+            iterator = p.rglob("*")
+        else:
+            iterator = p.iterdir()
+        total_searched = 0
+        for fp in iterator:
+            if not fp.is_file():
+                continue
+            total_searched += 1
+            ext_key = _file_ext_key(fp)
+            if ext_key in pod5_exts:
+                pod5_paths.append(str(fp))
+            elif ext_key in fast5_exts:
+                fast5_paths.append(str(fp))
+            elif ext_key in fastq_exts:
+                fastq_paths.append(str(fp))
+            elif ext_key == bam_suffix:
+                bam_paths.append(str(fp))
+            else:
+                # additional heuristic: check filename contains extension fragments (.pod5 etc)
+                name = fp.name.lower()
+                if any(e in name for e in pod5_exts):
+                    pod5_paths.append(str(fp))
+                elif any(e in name for e in fast5_exts):
+                    fast5_paths.append(str(fp))
+                elif any(e in name for e in [".fastq", ".fq"]):
+                    fastq_paths.append(str(fp))
+                elif name.endswith(bam_suffix):
+                    bam_paths.append(str(fp))
+                else:
+                    other_paths.append(str(fp))
+    else:
+        raise FileNotFoundError(f"input_data_path does not exist: {input_data_path}")
+
+    return {
+        "pod5_paths": sorted(pod5_paths),
+        "fast5_paths": sorted(fast5_paths),
+        "fastq_paths": sorted(fastq_paths),
+        "bam_paths": sorted(bam_paths),
+        "other_paths": sorted(other_paths),
+        "input_is_pod5": len(pod5_paths) > 0,
+        "input_is_fast5": len(fast5_paths) > 0,
+        "input_is_fastq": len(fastq_paths) > 0,
+        "input_is_bam": len(bam_paths) > 0,
+        "all_files_searched": total_searched,
+    }

smftools/informatics/helpers/extract_base_identities.py

@@ -0,0 +1,70 @@
+def extract_base_identities(bam_file, chromosome, positions, max_reference_length, sequence):
+    """
+    Efficiently extracts base identities from mapped reads with reference coordinates.
+
+    Parameters:
+        bam_file (str): Path to the BAM file.
+        chromosome (str): Name of the reference chromosome.
+        positions (list): Positions to extract (0-based).
+        max_reference_length (int): Maximum reference length for padding.
+        sequence (str): The sequence of the record fasta
+
+    Returns:
+        dict: Base identities from forward mapped reads.
+        dict: Base identities from reverse mapped reads.
+    """
+    import pysam
+    import numpy as np
+    from collections import defaultdict
+    import time
+    from collections import defaultdict, Counter
+
+    timestamp = time.strftime("[%Y-%m-%d %H:%M:%S]")
+
+    positions = set(positions)
+    fwd_base_identities = defaultdict(lambda: np.full(max_reference_length, 'N', dtype='<U1'))
+    rev_base_identities = defaultdict(lambda: np.full(max_reference_length, 'N', dtype='<U1'))
+    mismatch_counts_per_read = defaultdict(lambda: defaultdict(Counter))
+
+    #print(f"{timestamp} Reading reads from {chromosome} BAM file: {bam_file}")
+    with pysam.AlignmentFile(bam_file, "rb") as bam:
+        total_reads = bam.mapped
+        ref_seq = sequence.upper()
+        for read in bam.fetch(chromosome):
+            if not read.is_mapped:
+                continue  # Skip unmapped reads
+
+            read_name = read.query_name
+            query_sequence = read.query_sequence
+            base_dict = rev_base_identities if read.is_reverse else fwd_base_identities
+
+            # Use get_aligned_pairs directly with positions filtering
+            aligned_pairs = read.get_aligned_pairs(matches_only=True)
+
+            for read_position, reference_position in aligned_pairs:
+                if reference_position in positions:
+                    read_base = query_sequence[read_position]
+                    ref_base = ref_seq[reference_position]
+
+                    base_dict[read_name][reference_position] = read_base
+
+                # Track mismatches (excluding Ns)
+                if read_base != ref_base and read_base != 'N' and ref_base != 'N':
+                    mismatch_counts_per_read[read_name][ref_base][read_base] += 1
+
+    # Determine C→T vs G→A dominance per read
+    mismatch_trend_per_read = {}
+    for read_name, ref_dict in mismatch_counts_per_read.items():
+        c_to_t = ref_dict.get("C", {}).get("T", 0)
+        g_to_a = ref_dict.get("G", {}).get("A", 0)
+
+        if abs(c_to_t - g_to_a) < 0.01 and c_to_t > 0:
+            mismatch_trend_per_read[read_name] = "equal"
+        elif c_to_t > g_to_a:
+            mismatch_trend_per_read[read_name] = "C->T"
+        elif g_to_a > c_to_t:
+            mismatch_trend_per_read[read_name] = "G->A"
+        else:
+            mismatch_trend_per_read[read_name] = "none"
+
+    return dict(fwd_base_identities), dict(rev_base_identities), dict(mismatch_counts_per_read), mismatch_trend_per_read

smftools/informatics/helpers/extract_mods.py

@@ -0,0 +1,83 @@
+## extract_mods
+
+def extract_mods(thresholds, mod_tsv_dir, split_dir, bam_suffix, skip_unclassified=True, modkit_summary=False, threads=None):
+    """
+    Takes all of the aligned, sorted, split modified BAM files and runs Nanopore Modkit Extract to load the modification data into zipped TSV files
+
+    Parameters:
+        thresholds (list): A list of thresholds to use for marking each basecalled base as passing or failing on canonical and modification call status.
+        mod_tsv_dir (str): A string representing the file path to the directory to hold the modkit extract outputs.
+        split_dit (str): A string representing the file path to the directory containing the converted aligned_sorted_split BAM files.
+        bam_suffix (str): The suffix to use for the BAM file.
+        skip_unclassified (bool): Whether to skip unclassified bam file for modkit extract command
+        modkit_summary (bool): Whether to run and display modkit summary
+        threads (int): Number of threads to use
+
+    Returns:
+        None
+        Runs modkit extract on input aligned_sorted_split modified BAM files to output zipped TSVs containing modification calls.
+
+    """
+    import os
+    import subprocess
+    import glob
+    import zipfile
+    
+    os.chdir(mod_tsv_dir)
+    filter_threshold, m6A_threshold, m5C_threshold, hm5C_threshold = thresholds
+    bam_files = glob.glob(os.path.join(split_dir, f"*{bam_suffix}"))
+
+    if threads:
+        threads = str(threads)
+    else:
+        pass
+
+    for input_file in bam_files:
+        print(input_file)
+        # Extract the file basename
+        file_name = os.path.basename(input_file)
+        if skip_unclassified and "unclassified" in file_name:
+            print("Skipping modkit extract on unclassified reads")
+        else:
+            # Construct the output TSV file path
+            output_tsv_temp = os.path.join(mod_tsv_dir, file_name)
+            output_tsv = output_tsv_temp.replace(bam_suffix, "") + "_extract.tsv"
+            if os.path.exists(f"{output_tsv}.gz"):
+                print(f"{output_tsv}.gz already exists, skipping modkit extract")
+            else:
+                print(f"Extracting modification data from {input_file}")
+                if modkit_summary:
+                    # Run modkit summary
+                    subprocess.run(["modkit", "summary", input_file])
+                else:
+                    pass
+                # Run modkit extract
+                if threads:
+                    extract_command = [
+                        "modkit", "extract",
+                        "calls", "--mapped-only",
+                        "--filter-threshold", f'{filter_threshold}',
+                        "--mod-thresholds", f"m:{m5C_threshold}",
+                        "--mod-thresholds", f"a:{m6A_threshold}",
+                        "--mod-thresholds", f"h:{hm5C_threshold}",
+                        "-t", threads,
+                        input_file, output_tsv
+                        ]
+                else:
+                    extract_command = [
+                        "modkit", "extract",
+                        "calls", "--mapped-only",
+                        "--filter-threshold", f'{filter_threshold}',
+                        "--mod-thresholds", f"m:{m5C_threshold}",
+                        "--mod-thresholds", f"a:{m6A_threshold}",
+                        "--mod-thresholds", f"h:{hm5C_threshold}",
+                        input_file, output_tsv
+                        ]                    
+                subprocess.run(extract_command)
+                # Zip the output TSV
+                print(f'zipping {output_tsv}')
+                if threads:
+                    zip_command = ["pigz", "-f", "-p", threads, output_tsv]
+                else:
+                    zip_command = ["pigz", "-f", output_tsv]
+                subprocess.run(zip_command, check=True)

smftools/informatics/helpers/extract_read_features_from_bam.py

@@ -0,0 +1,33 @@
+# extract_read_features_from_bam
+
+def extract_read_features_from_bam(bam_file_path):
+    """
+    Make a dict of reads from a bam that points to a list of read metrics: read length, read median Q-score, reference length, mapped length, mapping quality
+    Params:
+        bam_file_path (str):
+    Returns:
+        read_metrics (dict)
+    """
+    import pysam
+    import numpy as np
+    # Open the BAM file
+    print(f'Extracting read features from BAM: {bam_file_path}')
+    with pysam.AlignmentFile(bam_file_path, "rb") as bam_file:
+        read_metrics = {}
+        reference_lengths = bam_file.lengths  # List of lengths for each reference (chromosome)
+        for read in bam_file:
+            # Skip unmapped reads
+            if read.is_unmapped:
+                continue
+            # Extract the read metrics
+            read_quality = read.query_qualities
+            median_read_quality = np.median(read_quality)
+            # Extract the reference (chromosome) name and its length
+            reference_name = read.reference_name
+            reference_index = bam_file.references.index(reference_name)
+            reference_length = reference_lengths[reference_index]
+            mapped_length = sum(end - start for start, end in read.get_blocks())
+            mapping_quality = read.mapping_quality  # Phred-scaled MAPQ
+            read_metrics[read.query_name] = [read.query_length, median_read_quality, reference_length, mapped_length, mapping_quality]
+
+    return read_metrics

smftools/informatics/helpers/extract_read_lengths_from_bed.py

@@ -0,0 +1,25 @@
+# extract_read_lengths_from_bed
+
+def extract_read_lengths_from_bed(file_path):
+    """
+    Load a dict of read names that points to the read length
+
+    Params:
+        file_path (str): file path to a bed file
+    Returns:
+        read_dict (dict)
+    """
+    import pandas as pd
+    columns = ['chrom', 'start', 'end', 'length', 'name']
+    df = pd.read_csv(file_path, sep='\t', header=None, names=columns, comment='#')
+    read_dict = {}
+    for _, row in df.iterrows():
+        chrom = row['chrom']
+        start = row['start']
+        end = row['end']
+        name = row['name']
+        length = row['length']
+        read_dict[name] = length
+
+    return read_dict
+        

smftools/informatics/helpers/extract_readnames_from_BAM.py

@@ -0,0 +1,22 @@
+# extract_readnames_from_BAM
+
+def extract_readnames_from_BAM(aligned_BAM):
+    """
+    Takes a BAM and writes out a txt file containing read names from the BAM
+
+    Parameters:
+        aligned_BAM (str): Path to an input aligned_BAM to extract read names from.
+
+    Returns:
+        None
+
+    """
+    import subprocess
+    # Make a text file of reads for the BAM
+    txt_output = aligned_BAM.split('.bam')[0] + '_read_names.txt'
+    samtools_view = subprocess.Popen(["samtools", "view", aligned_BAM], stdout=subprocess.PIPE)
+    with open(txt_output, "w") as output_file:
+        cut_process = subprocess.Popen(["cut", "-f1"], stdin=samtools_view.stdout, stdout=output_file)   
+    samtools_view.stdout.close()
+    cut_process.wait()
+    samtools_view.wait()

smftools/informatics/helpers/find_conversion_sites.py

@@ -0,0 +1,51 @@
+def find_conversion_sites(fasta_file, modification_type, conversions, deaminase_footprinting=False):
+    """
+    Finds genomic coordinates of modified bases (5mC or 6mA) in a reference FASTA file.
+
+    Parameters:
+        fasta_file (str): Path to the converted reference FASTA.
+        modification_type (str): Modification type ('5mC' or '6mA') or 'unconverted'.
+        conversions (list): List of conversion types. The first element is the unconverted record type.
+        deaminase_footprinting (bool): Whether the footprinting was done with a direct deamination chemistry.
+
+    Returns: 
+        dict: Dictionary where keys are **both unconverted & converted record names**.
+              Values contain:
+              [sequence length, top strand coordinates, bottom strand coordinates, sequence, complement sequence].
+    """
+    import numpy as np
+    from Bio import SeqIO
+    unconverted = conversions[0]
+    record_dict = {}
+
+    # Define base mapping based on modification type
+    base_mappings = {
+        '5mC': ('C', 'G'),  # Cytosine and Guanine
+        '6mA': ('A', 'T')   # Adenine and Thymine
+    }
+
+    # Read FASTA file and process records
+    with open(fasta_file, "r") as f:
+        for record in SeqIO.parse(f, "fasta"):
+            if unconverted in record.id or deaminase_footprinting:
+                sequence = str(record.seq).upper()
+                complement = str(record.seq.complement()).upper()
+                sequence_length = len(sequence)
+
+                # Unconverted case: store the full sequence without coordinate filtering
+                if modification_type == unconverted:
+                    record_dict[record.id] = [sequence_length, [], [], sequence, complement]
+
+                # Process converted records: extract modified base positions
+                elif modification_type in base_mappings:
+                    top_base, bottom_base = base_mappings[modification_type]
+                    seq_array = np.array(list(sequence))
+                    top_strand_coordinates = np.where(seq_array == top_base)[0].tolist()
+                    bottom_strand_coordinates = np.where(seq_array == bottom_base)[0].tolist()
+
+                    record_dict[record.id] = [sequence_length, top_strand_coordinates, bottom_strand_coordinates, sequence, complement]
+
+                else:
+                    raise ValueError(f"Invalid modification_type: {modification_type}. Choose '5mC', '6mA', or 'unconverted'.")
+
+    return record_dict

smftools/informatics/helpers/generate_converted_FASTA.py

@@ -0,0 +1,99 @@
+import numpy as np
+import gzip
+import os
+from Bio import SeqIO
+from Bio.SeqRecord import SeqRecord
+from Bio.Seq import Seq
+from concurrent.futures import ProcessPoolExecutor
+from itertools import chain
+
+def convert_FASTA_record(record, modification_type, strand, unconverted):
+    """ Converts a FASTA record based on modification type and strand. """
+    conversion_maps = {
+        ('5mC', 'top'): ('C', 'T'),
+        ('5mC', 'bottom'): ('G', 'A'),
+        ('6mA', 'top'): ('A', 'G'),
+        ('6mA', 'bottom'): ('T', 'C')
+    }
+
+    sequence = str(record.seq).upper()
+
+    if modification_type == unconverted:
+        return SeqRecord(Seq(sequence), id=f"{record.id}_{modification_type}_top", description=record.description)
+
+    if (modification_type, strand) not in conversion_maps:
+        raise ValueError(f"Invalid combination: {modification_type}, {strand}")
+
+    original_base, converted_base = conversion_maps[(modification_type, strand)]
+    new_seq = sequence.replace(original_base, converted_base)
+
+    return SeqRecord(Seq(new_seq), id=f"{record.id}_{modification_type}_{strand}", description=record.description)
+
+
+def process_fasta_record(args):
+    """
+    Processes a single FASTA record for parallel execution.
+    Args:
+        args (tuple): (record, modification_types, strands, unconverted)
+    Returns:
+        list of modified SeqRecord objects.
+    """
+    record, modification_types, strands, unconverted = args
+    modified_records = []
+    
+    for modification_type in modification_types:
+        for i, strand in enumerate(strands):
+            if i > 0 and modification_type == unconverted:
+                continue  # Ensure unconverted is added only once
+
+            modified_records.append(convert_FASTA_record(record, modification_type, strand, unconverted))
+
+    return modified_records
+
+
+def generate_converted_FASTA(input_fasta, modification_types, strands, output_fasta, num_threads=4, chunk_size=500):
+    """
+    Converts an input FASTA file and writes a new converted FASTA file efficiently.
+
+    Parameters:
+        input_fasta (str): Path to the unconverted FASTA file.
+        modification_types (list): List of modification types ('5mC', '6mA', or unconverted).
+        strands (list): List of strands ('top', 'bottom').
+        output_fasta (str): Path to the converted FASTA output file.
+        num_threads (int): Number of parallel threads to use.
+        chunk_size (int): Number of records to process per write batch.
+
+    Returns:
+        None (Writes the converted FASTA file).
+    """
+    unconverted = modification_types[0]
+
+    # Detect if input is gzipped
+    open_func = gzip.open if input_fasta.endswith('.gz') else open
+    file_mode = 'rt' if input_fasta.endswith('.gz') else 'r'
+
+    def fasta_record_generator():
+        """ Lazily yields FASTA records from file. """
+        with open_func(input_fasta, file_mode) as handle:
+            for record in SeqIO.parse(handle, 'fasta'):
+                yield record
+
+    with open(output_fasta, 'w') as output_handle, ProcessPoolExecutor(max_workers=num_threads) as executor:
+        # Process records in parallel using a named function (avoiding lambda)
+        results = executor.map(
+            process_fasta_record,
+            ((record, modification_types, strands, unconverted) for record in fasta_record_generator())
+        )
+
+        buffer = []
+        for modified_records in results:
+            buffer.extend(modified_records)
+
+            # Write out in chunks to save memory
+            if len(buffer) >= chunk_size:
+                SeqIO.write(buffer, output_handle, 'fasta')
+                buffer.clear()
+
+        # Write any remaining records
+        if buffer:
+            SeqIO.write(buffer, output_handle, 'fasta')

smftools/informatics/helpers/get_chromosome_lengths.py

@@ -0,0 +1,32 @@
+# get_chromosome_lengths
+
+def get_chromosome_lengths(fasta):
+    """
+    Generates a file containing chromosome lengths within an input FASTA.
+
+    Parameters:
+        fasta (str): Path to the input fasta
+    """
+    import os
+    import subprocess
+    from .index_fasta import index_fasta
+
+    # Make a fasta index file if one isn't already available
+    index_path = f'{fasta}.fai'
+    if os.path.exists(index_path):
+        print(f'Using existing fasta index file: {index_path}')
+    else:
+        index_fasta(fasta)
+
+    parent_dir = os.path.dirname(fasta)
+    fasta_basename = os.path.basename(fasta)
+    chrom_basename = fasta_basename.split('.fa')[0] + '.chrom.sizes'
+    chrom_path = os.path.join(parent_dir, chrom_basename)
+
+    # Make a chromosome length file
+    if os.path.exists(chrom_path):
+        print(f'Using existing chrom length index file: {chrom_path}')
+    else:
+        with open(chrom_path, 'w') as outfile:
+            command = ["cut", "-f1,2", index_path]
+            subprocess.run(command, stdout=outfile)

smftools/informatics/helpers/get_native_references.py

@@ -0,0 +1,28 @@
+## get_native_references
+
+# Direct methylation specific
+def get_native_references(fasta_file):
+    """
+    Makes a dictionary keyed by record id which points to the record length and record sequence.
+
+    Paramaters:
+        fasta_file (str): A string representing the path to the FASTA file for the experiment.
+
+    Returns: 
+        None
+    """
+    from .. import readwrite
+    from Bio import SeqIO
+    from Bio.SeqRecord import SeqRecord
+    from Bio.Seq import Seq
+    record_dict = {}
+    print('{0}: Opening FASTA file {1}'.format(readwrite.time_string(), fasta_file))
+    # Open the FASTA record as read only
+    with open(fasta_file, "r") as f:
+        # Iterate over records in the FASTA
+        for record in SeqIO.parse(f, "fasta"):
+            # Extract the sequence string of the record
+            sequence = str(record.seq).upper()
+            sequence_length = len(sequence) 
+            record_dict[record.id] = [sequence_length, sequence]
+    return record_dict

smftools/informatics/helpers/index_fasta.py

@@ -0,0 +1,12 @@
+# index_fasta
+
+def index_fasta(fasta):
+    """
+    Generate a FASTA index file for an input fasta.
+
+    Parameters:
+        fasta (str): Path to the input fasta to make an index file for.
+    """
+    import subprocess
+
+    subprocess.run(["samtools", "faidx", fasta])

smftools/informatics/helpers/make_dirs.py

@@ -0,0 +1,21 @@
+## make_dirs
+
+# General
+def make_dirs(directories):
+    """
+    Takes a list of file paths and makes new directories if the directory does not already exist.
+
+    Parameters:
+        directories (list): A list of directories to make
+    
+    Returns:
+        None
+    """
+    import os
+
+    for directory in directories:
+        if not os.path.isdir(directory):
+            os.mkdir(directory)
+            print(f"Directory '{directory}' created successfully.")
+        else:
+            print(f"Directory '{directory}' already exists.")

smftools/informatics/helpers/make_modbed.py

@@ -0,0 +1,27 @@
+## make_modbed
+
+# Direct SMF
+def make_modbed(aligned_sorted_output, thresholds, mod_bed_dir):
+    """
+    Generating position methylation summaries for each barcoded sample starting from the overall BAM file that was direct output of dorado aligner.
+    Parameters:
+        aligned_sorted_output (str): A string representing the file path to the aligned_sorted non-split BAM file.
+    
+    Returns:
+        None
+    """
+    import os
+    import subprocess
+    
+    os.chdir(mod_bed_dir)
+    filter_threshold, m6A_threshold, m5C_threshold, hm5C_threshold = thresholds
+    command = [
+        "modkit", "pileup", aligned_sorted_output, mod_bed_dir,
+        "--partition-tag", "BC",
+        "--only-tabs",
+        "--filter-threshold", f'{filter_threshold}',
+        "--mod-thresholds", f"m:{m5C_threshold}",
+        "--mod-thresholds", f"a:{m6A_threshold}",
+        "--mod-thresholds", f"h:{hm5C_threshold}"
+    ]
+    subprocess.run(command)

smftools/informatics/helpers/modQC.py

@@ -0,0 +1,27 @@
+## modQC
+
+# Direct SMF
+def modQC(aligned_sorted_output, thresholds):
+    """
+    Output the percentile of bases falling at a call threshold (threshold is a probability between 0-1) for the overall BAM file.
+    It is generally good to look at these parameters on positive and negative controls.
+
+    Parameters:
+        aligned_sorted_output (str): A string representing the file path of the aligned_sorted non-split BAM file output by the dorado aligned.
+        thresholds (list): A list of floats to pass for call thresholds.
+
+    Returns:
+        None
+    """
+    import subprocess
+
+    filter_threshold, m6A_threshold, m5C_threshold, hm5C_threshold = thresholds
+    subprocess.run(["modkit", "sample-probs", aligned_sorted_output])
+    command = [
+        "modkit", "summary", aligned_sorted_output,
+        "--filter-threshold", f"{filter_threshold}",
+        "--mod-thresholds", f"m:{m5C_threshold}",
+        "--mod-thresholds", f"a:{m6A_threshold}",
+        "--mod-thresholds", f"h:{hm5C_threshold}"
+    ]
+    subprocess.run(command)