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

smftools/informatics/helpers/find_conversion_sites.py

@@ -0,0 +1,50 @@
+def find_conversion_sites(fasta_file, modification_type, conversion_types):
+    """
+    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'.
+        conversion_types (list): List of conversion types. The first element is the unconverted record type.
+
+    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 = conversion_types[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:
+                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)

smftools/informatics/helpers/modcall.py

@@ -0,0 +1,36 @@
+## modcall
+
+# Direct methylation specific
+def modcall(model_dir, model, pod5_dir, barcode_kit, mod_list, bam, bam_suffix, barcode_both_ends=True, trim=False, device='auto'):
+    """
+    Wrapper function for dorado modified base calling.
+
+    Parameters:
+        model_dir (str): a string representing the file path to the dorado basecalling model directory.
+        model (str): a string representing the the dorado basecalling model.
+        pod5_dir (str): a string representing the file path to the experiment directory containing the POD5 files.
+        barcode_kit (str): A string representing the barcoding kit used in the experiment.
+        mod_list (list): A list of modification types to use in the analysis.
+        bam (str): File path to the BAM file to output.
+        bam_suffix (str): The suffix to use for the BAM file.
+        barcode_both_ends (bool): Whether to require a barcode detection on both ends for demultiplexing.
+        trim (bool): Whether to trim barcodes, adapters, and primers from read ends
+        device (str): Device to use for basecalling. auto, metal, cpu, cuda.
+    
+    Returns:
+        None
+            Outputs a BAM file holding the modified base calls output by the dorado basecaller.
+    """
+    import subprocess
+    output = bam + bam_suffix
+    command = ["dorado", "basecaller", "--models-directory", model_dir, "--kit-name", barcode_kit, "--modified-bases"]
+    command += mod_list
+    command += ["--device", device, "--batchsize", "0"]
+    if barcode_both_ends:
+        command.append("--barcode-both-ends")
+    if not trim:
+        command.append("--no-trim")
+    command += [model, pod5_dir]
+    print(f'Running: {" ".join(command)}')
+    with open(output, "w") as outfile:
+        subprocess.run(command, stdout=outfile)