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

smftools/informatics/helpers/converted_BAM_to_adata.py

@@ -1,164 +0,0 @@
-## converted_BAM_to_adata
-
-def converted_BAM_to_adata(converted_FASTA, split_dir, mapping_threshold, experiment_name, conversion_types, bam_suffix):
-    """
-    A wrapper function to take converted aligned_sorted_split BAM files and format the data into an anndata object.
-
-    Parameters:
-        converted_FASTA (str): A string representing the file path to the converted FASTA reference.
-        split_dir (str): A string representing the file path to the directory containing the converted aligned_sorted_split BAM files.
-        mapping_threshold (float): A value in between 0 and 1 to threshold the minimal fraction of aligned reads which map to the reference region. References with values above the threshold are included in the output adata.
-        experiment_name (str): A string to provide an experiment name to the output adata file.
-        conversion_types (list): A list of strings of the conversion types to use in the analysis.
-        bam_suffix (str): The suffix to use for the BAM file.
-    
-    Returns:
-        None
-        Outputs a single gzipped adata object for the experiment.
-    """
-    from .. import readwrite
-    from .binarize_converted_base_identities import binarize_converted_base_identities
-    from .find_conversion_sites import find_conversion_sites
-    from .count_aligned_reads import count_aligned_reads
-    from .extract_base_identities import extract_base_identities
-    from .one_hot_encode import one_hot_encode
-    import pandas as pd
-    import numpy as np
-    import anndata as ad
-    import os
-
-    # Get all of the input BAM files
-    files = os.listdir(split_dir)
-    # Change directory to the BAM directory
-    os.chdir(split_dir)
-    # Filter file names that contain the search string in their filename and keep them in a list
-    bams = [bam for bam in files if bam_suffix in bam and '.bai' not in bam]
-    # Sort file list by names and print the list of file names
-    bams.sort()
-    print(f'Found the following BAMS: {bams}')
-    final_adata = None
-
-    # Make a dictionary, keyed by modification type, that points to another dictionary of unconverted_record_ids. This points to a list of: 1) record length, 2) top strand conversion coordinates, 3) bottom strand conversion coordinates, 4) record sequence
-    modification_dict = {}
-    # While populating the dictionary, also extract the longest sequence record in the input references
-    max_reference_length = 0
-    for conversion_type in conversion_types:
-        modification_dict[conversion_type] = find_conversion_sites(converted_FASTA, conversion_type, conversion_types)
-        for record in modification_dict[conversion_type].keys():
-            if modification_dict[conversion_type][record][0] > max_reference_length:
-                max_reference_length = modification_dict[conversion_type][record][0]
-
-    # Init a dict to be keyed by FASTA record that points to the sequence string of the unconverted record
-    record_FASTA_dict = {}
-
-    # Iterate over the experiment BAM files
-    for bam_index, bam in enumerate(bams):
-        # Give each bam a sample name
-        sample = bam.split(sep=bam_suffix)[0]
-        # look at aligned read proportions in the bam
-        aligned_reads_count, unaligned_reads_count, record_counts = count_aligned_reads(bam)
-        percent_aligned = aligned_reads_count*100 / (aligned_reads_count+unaligned_reads_count)
-        print(f'{percent_aligned} percent of total reads in {bam} aligned successfully')
-        records_to_analyze = []
-        # Iterate over converted reference strands and decide which to use in the analysis based on the mapping_threshold
-        for record in record_counts:
-            print(f'{record_counts[record][0]} reads mapped to reference record {record}. This is {record_counts[record][1]*100} percent of all mapped reads in the sample.')
-            if record_counts[record][1] >= mapping_threshold:
-                records_to_analyze.append(record)
-        print(f'Records to analyze: {records_to_analyze}')
-        # Iterate over records to analyze (ie all conversions detected)
-        for record in records_to_analyze:
-            mod_type, strand = record.split('_')[-2:]
-            if strand == 'top':
-                strand_index = 1
-            elif strand == 'bottom':
-                strand_index = 2
-
-            chromosome = record.split('_{0}_{1}'.format(mod_type, strand))[0]
-            unconverted_chromosome_name = f'{chromosome}_{conversion_types[0]}_top'
-            positions = modification_dict[mod_type][unconverted_chromosome_name][strand_index]
-            current_reference_length = modification_dict[mod_type][unconverted_chromosome_name][0]
-            delta_max_length = max_reference_length - current_reference_length
-            sequence = modification_dict[mod_type][unconverted_chromosome_name][3] + 'N'*delta_max_length
-            record_FASTA_dict[f'{record}'] = sequence
-            print(f'Chromosome: {chromosome}\nUnconverted Sequence: {sequence}')
-
-            # Get a dictionary of positional identities keyed by read id
-            print(f'Extracting base identities of target positions')
-            target_base_identities = extract_base_identities(bam, record, positions, max_reference_length) 
-            # binarize the dictionary of positional identities
-            print(f'Binarizing base identities of target positions')
-            binarized_base_identities = binarize_converted_base_identities(target_base_identities, strand, mod_type) 
-            # converts the base identity dictionary to a dataframe.
-            binarized_base_identities_df = pd.DataFrame.from_dict(binarized_base_identities, orient='index') 
-            sorted_index = sorted(binarized_base_identities_df.index)
-            binarized_base_identities_df = binarized_base_identities_df.reindex(sorted_index)
-            # Get the sequence string of every read
-            print(f'Extracting base identities of all positions in each read')
-            all_base_identities = extract_base_identities(bam, record, range(current_reference_length), max_reference_length)
-            # One hot encode the sequence string of the reads
-            print(f'One hot encoding base identities of all positions in each read')
-            one_hot_reads = {read_name: one_hot_encode(seq) for read_name, seq in all_base_identities.items()}
-
-            # Initialize empty DataFrames for each base
-            read_names = list(one_hot_reads.keys())
-            sequence_length = one_hot_reads[read_names[0]].shape[0]
-            df_A = pd.DataFrame(0, index=sorted_index, columns=range(sequence_length))
-            df_C = pd.DataFrame(0, index=sorted_index, columns=range(sequence_length))
-            df_G = pd.DataFrame(0, index=sorted_index, columns=range(sequence_length))
-            df_T = pd.DataFrame(0, index=sorted_index, columns=range(sequence_length))
-            df_N = pd.DataFrame(0, index=sorted_index, columns=range(sequence_length))
-
-            # Iterate through the dictionary and populate the DataFrames
-            for read_name, one_hot_array in one_hot_reads.items():
-                df_A.loc[read_name] = one_hot_array[:, 0]
-                df_C.loc[read_name] = one_hot_array[:, 1]
-                df_G.loc[read_name] = one_hot_array[:, 2]
-                df_T.loc[read_name] = one_hot_array[:, 3]
-                df_N.loc[read_name] = one_hot_array[:, 4]
-
-            ohe_df_map = {0: df_A, 1: df_C, 2: df_G, 3: df_T, 4: df_N}   
-
-            # Load an anndata object with the sample data
-            X = binarized_base_identities_df.values
-            adata = ad.AnnData(X, dtype=X.dtype)
-            adata.obs_names = binarized_base_identities_df.index
-            adata.obs_names = adata.obs_names.astype(str)
-            adata.var_names = binarized_base_identities_df.columns
-            adata.var_names = adata.var_names.astype(str)
-            adata.obs['Sample'] = [sample] * len(adata)
-            adata.obs['Strand'] = [strand] * len(adata)
-            adata.obs['Dataset'] = [mod_type] * len(adata)
-            adata.obs['Reference'] = [record] * len(adata)
-            adata.obs['Reference_chromosome'] = [chromosome] * len(adata)
-            
-            for j, base in enumerate(['A', 'C', 'G', 'T', 'N']):
-                adata.layers[f'{base}_binary_encoding'] = ohe_df_map[j].values 
-
-            if final_adata:
-                final_adata = ad.concat([final_adata, adata], join='outer', index_unique=None)
-            else:
-                final_adata = adata
-
-    for record in record_FASTA_dict.keys():
-        chromosome = record.split('_')[0]
-        sequence = record_FASTA_dict[record]
-        final_adata.uns[f'{record}_FASTA_sequence'] = sequence
-        final_adata.var[f'{record}_FASTA_sequence'] = list(sequence)
-
-        # May need to remove the bottom for conversion SMF
-        record_subset = final_adata[final_adata.obs['Reference'] == record].copy()
-        layer_map, layer_counts = {}, []
-        for i, layer in enumerate(record_subset.layers):
-            layer_map[i] = layer.split('_')[0]
-            layer_counts.append(np.sum(record_subset.layers[layer], axis=0))
-        count_array = np.array(layer_counts)
-        nucleotide_indexes = np.argmax(count_array, axis=0)
-        consensus_sequence_list = [layer_map[i] for i in nucleotide_indexes]
-        final_adata.var[f'{record}_consensus_across_samples'] = consensus_sequence_list
-
-    ######################################################################################################
-
-    ######################################################################################################
-    ## Export the final adata object
-    final_adata.write_h5ad('{0}_{1}.h5ad.gz'.format(readwrite.date_string(), experiment_name), compression='gzip')

smftools/informatics/helpers/count_aligned_reads.py

@@ -1,39 +0,0 @@
-## count_aligned_reads
-
-# General
-def count_aligned_reads(bam_file):
-    """
-    Counts the number of aligned reads in a bam file that map to each reference record.
-    
-    Parameters:
-        bam_file (str): A string representing the path to an aligned BAM file.
-    
-    Returns:
-       aligned_reads_count (int): The total number or reads aligned in the BAM.
-       unaligned_reads_count (int): The total number of reads not aligned in the BAM.
-       record_counts (dict): A dictionary keyed by reference record instance that points toa tuple containing the total reads mapped to the record and the fraction of mapped reads which map to the record.
-
-    """
-    from .. import readwrite
-    import pysam
-    print('{0}: Counting aligned reads in BAM > {1}'.format(readwrite.time_string(), bam_file))
-    aligned_reads_count = 0
-    unaligned_reads_count = 0
-    # Make a dictionary, keyed by the reference_name of reference chromosome that points to an integer number of read counts mapped to the chromosome, as well as the proportion of mapped reads in that chromosome
-    record_counts = {}
-    with pysam.AlignmentFile(bam_file, "rb") as bam:
-        # Iterate over reads to get the total mapped read counts and the reads that map to each reference
-        for read in bam:
-            if read.is_unmapped: 
-                unaligned_reads_count += 1
-            else: 
-                aligned_reads_count += 1
-                if read.reference_name in record_counts:
-                    record_counts[read.reference_name] += 1
-                else:
-                    record_counts[read.reference_name] = 1
-        # reformat the dictionary to contain read counts mapped to the reference, as well as the proportion of mapped reads in reference
-        for reference in record_counts:
-            proportion_mapped_reads_in_record = record_counts[reference] / aligned_reads_count
-            record_counts[reference] = (record_counts[reference], proportion_mapped_reads_in_record)
-    return aligned_reads_count, unaligned_reads_count, record_counts

smftools/informatics/helpers/extract_base_identities.py

@@ -1,43 +0,0 @@
-## extract_base_identities
-
-# General
-def extract_base_identities(bam_file, chromosome, positions, max_reference_length):
-    """
-    Extracts the base identities from every position within the read that has a reference coordinate
-
-    Parameters:
-        bam (str): File path to the BAM file to align (excluding the file suffix).
-        chromosome (str): A string representing the name of the record within the reference FASTA.
-        positions (list): A list of position coordinates within the record to extract.
-        max_reference_length (int): The maximum length of a record in the reference set.
-
-    Returns:
-        base_identities (dict): A dictionary, keyed by read name, that points to a list of base identities. If the read does not contain that position, fill the list at that index with a N value.
-    
-    """
-    from .. import readwrite
-    import pysam
-    positions = set(positions)
-    # Initialize a base identity dictionary that will hold key-value pairs that are: key (read-name) and value (list of base identities at positions of interest)
-    base_identities = {}
-    # Open the postion sorted BAM file
-    print('{0}: Reading BAM file: {1}'.format(readwrite.time_string(), bam_file))
-    with pysam.AlignmentFile(bam_file, "rb") as bam:
-        # Iterate over every read in the bam that comes from the chromosome of interest
-        print('{0}: Iterating over reads in bam'.format(readwrite.time_string()))
-        for read in bam.fetch(chromosome): 
-            if read.query_name in base_identities:
-                pass
-                #print('Duplicate read found in BAM for read {}. Skipping duplicate'.format(read.query_name))
-            else:          
-                # Initialize the read key in the base_identities dictionary by pointing to a N filled list of length reference_length
-                base_identities[read.query_name] = ['N'] * max_reference_length
-                # Iterate over a list of tuples for the given read. The tuples contain the 0-indexed position relative to the read start, as well the 0-based index relative to the reference.
-                for read_position, reference_position in read.get_aligned_pairs():
-                    # If the aligned read's reference coordinate is in the positions set and if the read position was successfully mapped
-                    if reference_position in positions and read_position:
-                        # get the base_identity in the read corresponding to that position
-                        base_identity = read.query_sequence[read_position]
-                        # Add the base identity to array
-                        base_identities[read.query_name][reference_position] = base_identity
-    return base_identities

smftools/informatics/helpers/extract_mods.py

@@ -1,51 +0,0 @@
-## extract_mods
-
-def extract_mods(thresholds, mod_tsv_dir, split_dir, bam_suffix):
-    """
-    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.
-
-    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}"))
-    for input_file in bam_files:
-        print(input_file)
-        # Extract the file basename
-        file_name = os.path.basename(input_file)
-        # 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"
-        # Run modkit summary
-        subprocess.run(["modkit", "summary", input_file])
-        # Run modkit extract
-        subprocess.run([
-            "modkit", "extract",
-            "--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, "null",
-            "--read-calls", output_tsv
-        ])
-        # Zip the output TSV
-        print(f'zipping {output_tsv}')
-        with zipfile.ZipFile(f"{output_tsv}.zip", 'w', zipfile.ZIP_DEFLATED) as zipf:
-            zipf.write(output_tsv, os.path.basename(output_tsv))
-        # Remove the non-zipped TSV
-        print(f'removing {output_tsv}')
-        os.remove(output_tsv)

smftools/informatics/helpers/find_conversion_sites.py

@@ -1,59 +0,0 @@
-## find_conversion_sites
-
-def find_conversion_sites(fasta_file, modification_type, conversion_types):
-    """
-    A function to find genomic coordinates in every unconverted record contained within a FASTA file of every cytosine.
-    If searching for adenine conversions, it will find coordinates of all adenines.
-
-    Parameters:
-        fasta_file (str): A string representing the file path to the unconverted reference FASTA.
-        modification_type (str): A string representing the modification type of interest (options are '5mC' and '6mA').
-        conversion_types (list): A list of strings of the conversion types to use in the analysis. Used here to pass the unconverted record name.
-
-    Returns: 
-        record_dict (dict): A dictionary keyed by unconverted record ids contained within the FASTA. Points to a list containing: 1) sequence length of the record, 2) top strand coordinate list, 3) bottom strand coorinate list, 4) sequence string
-    """
-    from .. import readwrite
-    from Bio import SeqIO
-    from Bio.SeqRecord import SeqRecord
-    from Bio.Seq import Seq
-    
-    print('{0}: Finding positions of interest in reference FASTA > {1}'.format(readwrite.time_string(), fasta_file))
-    # Initialize lists to hold top and bottom strand positional coordinates of interest
-    top_strand_coordinates = []
-    bottom_strand_coordinates = []
-    unconverted = conversion_types[0]
-    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"):
-            # Only iterate over the unconverted records for the reference
-            if unconverted in record.id:
-                print('{0}: Iterating over record {1} in FASTA file {2}'.format(readwrite.time_string(), record, fasta_file))
-                # Extract the sequence string of the record
-                sequence = str(record.seq).upper()
-                sequence_length = len(sequence)
-                if modification_type == '5mC':
-                    # Iterate over the sequence string from the record
-                    for i in range(0, len(sequence)):
-                        if sequence[i] == 'C':
-                            top_strand_coordinates.append(i)  # 0-indexed coordinate
-                        if sequence[i] == 'G':
-                            bottom_strand_coordinates.append(i)  # 0-indexed coordinate      
-                    print('{0}: Returning zero-indexed top and bottom strand FASTA coordinates for all cytosines'.format(readwrite.time_string()))
-                elif modification_type == '6mA':
-                    # Iterate over the sequence string from the record
-                    for i in range(0, len(sequence)):
-                        if sequence[i] == 'A':
-                            top_strand_coordinates.append(i)  # 0-indexed coordinate
-                        if sequence[i] == 'T':
-                            bottom_strand_coordinates.append(i)  # 0-indexed coordinate      
-                    print('{0}: Returning zero-indexed top and bottom strand FASTA coordinates for adenines of interest'.format(readwrite.time_string()))          
-                else:
-                    print('modification_type not found. Please try 5mC or 6mA')    
-                record_dict[record.id] = [sequence_length, top_strand_coordinates, bottom_strand_coordinates, sequence]
-            else:
-                pass  
-    return record_dict

smftools/informatics/helpers/generate_converted_FASTA.py

@@ -1,79 +0,0 @@
-## generate_converted_FASTA
-
-def convert_FASTA_record(record, modification_type, strand, unconverted):
-    """
-    Takes a FASTA record and converts every instance of a base to the converted state.
-
-    Parameters:
-        record (str): The name of the record instance within the FASTA.
-        modification_type (str): The modification type to convert for (options are '5mC' and '6mA').
-        strand (str): The strand that is being converted in the experiment (options are 'top' and 'bottom').
-    Returns:
-        new_seq (str): Converted sequence string.
-        new_id (str): Record id for the converted sequence string.
-    """
-    if modification_type == '5mC':
-        if strand == 'top':
-            # Replace every 'C' with 'T' in the sequence
-            new_seq = record.seq.upper().replace('C', 'T')
-        elif strand == 'bottom':
-            # Replace every 'G' with 'A' in the sequence
-            new_seq = record.seq.upper().replace('G', 'A')
-        else:
-            print('need to provide a valid strand string: top or bottom')
-        new_id = '{0}_{1}_{2}'.format(record.id, modification_type, strand)        
-    elif modification_type == '6mA':
-        if strand == 'top':
-            # Replace every 'A' with 'G' in the sequence
-            new_seq = record.seq.upper().replace('A', 'G')
-        elif strand == 'bottom':
-            # Replace every 'T' with 'C' in the sequence
-            new_seq = record.seq.upper().replace('T', 'C')
-        else:
-            print('need to provide a valid strand string: top or bottom')
-        new_id = '{0}_{1}_{2}'.format(record.id, modification_type, strand)
-    elif modification_type == unconverted:
-        new_seq = record.seq.upper()
-        new_id = '{0}_{1}_top'.format(record.id, modification_type)
-    else:
-        print(f'need to provide a valid modification_type string: 5mC, 6mA, or {unconverted}')   
-          
-    return new_seq, new_id
-
-def generate_converted_FASTA(input_fasta, modification_types, strands, output_fasta):
-    """
-    Uses modify_sequence_and_id function on every record within the FASTA to write out a converted FASTA.
-
-    Parameters:
-        input_FASTA (str): A string representing the path to the unconverted FASTA file.
-        modification_types (list): A list of modification types to use in the experiment.
-        strands (list): A list of converstion strands to use in the experiment.
-        output_FASTA (str): A string representing the path to the converted FASTA output file.
-    Returns:
-        None
-        Writes out a converted FASTA reference for the experiment.
-    """
-    from .. import readwrite
-    from Bio import SeqIO
-    from Bio.SeqRecord import SeqRecord
-    from Bio.Seq import Seq
-    modified_records = []
-    unconverted = modification_types[0]
-    # Iterate over each record in the input FASTA
-    for record in SeqIO.parse(input_fasta, 'fasta'):
-        record_description = record.description
-        # Iterate over each modification type of interest
-        for modification_type in modification_types:
-            # Iterate over the strands of interest
-            for i, strand in enumerate(strands):
-                if i > 0 and modification_type == unconverted: # This ensures that the unconverted is only added once.
-                    pass
-                else:
-                    # Add the modified record to the list of modified records
-                    print(f'converting {modification_type} on the {strand} strand of record {record}')
-                    new_seq, new_id = convert_FASTA_record(record, modification_type, strand, unconverted)
-                    new_record = SeqRecord(Seq(new_seq), id=new_id, description=record_description)
-                    modified_records.append(new_record)
-    with open(output_fasta, 'w') as output_handle:
-        # write out the concatenated FASTA file of modified sequences
-        SeqIO.write(modified_records, output_handle, 'fasta')

smftools/informatics/helpers/get_native_references.py

@@ -1,28 +0,0 @@
-## 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/make_dirs.py

@@ -1,21 +0,0 @@
-## 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

@@ -1,27 +0,0 @@
-## 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

@@ -1,27 +0,0 @@
-## 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

@@ -1,26 +0,0 @@
-## modcall
-
-# Direct methylation specific
-def modcall(model, pod5_dir, barcode_kit, mod_list, bam, bam_suffix):
-    """
-    Wrapper function for dorado modified base calling.
-
-    Parameters:
-        model (str): a string representing the file path to 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.
-    
-    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", model, pod5_dir, "--kit-name", barcode_kit, "-Y",
-    "--modified-bases", ",".join(mod_list)]  # Join MOD_LIST elements with commas
-    with open(output, "w") as outfile:
-        subprocess.run(command, stdout=outfile)