smftools 0.1.0__py3-none-any.whl → 0.1.3__py3-none-any.whl

smftools/informatics/helpers/count_aligned_reads.py

@@ -1,32 +1,43 @@
 ## count_aligned_reads
-from .. import readwrite
-# bioinformatic operations
-import pysam
 
 # General
 def count_aligned_reads(bam_file):
     """
-    Input: A BAM alignment file.
-    Output: The number of aligned/unaligned reads in the BAM file. Also returns a dictionary, keyed by reference id that points to a tuple. The tuple contains an integer number of mapped reads to that reference, followed by the proportion of mapped reads that map to that reference
+    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
+    from tqdm import tqdm
+    from collections import defaultdict
+
     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 = {}
+    record_counts = defaultdict(int)
+
     with pysam.AlignmentFile(bam_file, "rb") as bam:
+        total_reads = bam.mapped + bam.unmapped
         # 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: 
+        for read in tqdm(bam, desc='Counting aligned reads in BAM', total=total_reads):
+            if read.is_unmapped:
                 unaligned_reads_count += 1
-            else: 
+            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
+                record_counts[read.reference_name] += 1  # Automatically increments if key exists, adds if not
+
         # 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
+
+    return aligned_reads_count, unaligned_reads_count, dict(record_counts)

smftools/informatics/helpers/extract_base_identities.py

@@ -1,36 +1,57 @@
 ## extract_base_identities
-from .. import readwrite
-# bioinformatic operations
-import pysam
 
 # General
 def extract_base_identities(bam_file, chromosome, positions, max_reference_length):
     """
-    Input: A position sorted BAM file, chromosome number, position coordinate set, and reference length to extract the base identitity from the read.
-    Output: A dictionary, keyed by read name, that points to a list of Base identities from each read.
-    If the read does not contain that position, fill the list at that index with a N value.
+    Extracts the base identities from every position within the mapped reads that have 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:
+        fwd_base_identities (dict): A dictionary, keyed by read name, that points to a list of base identities from forward mapped reads. If the read does not contain that position, fill the list at that index with a N value.
+        rev_base_identities (dict): A dictionary, keyed by read name, that points to a list of base identities from reverse mapped reads. If the read does not contain that position, fill the list at that index with a N value.
     """
+    from .. import readwrite
+    import pysam
+    from tqdm import tqdm
+    
     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 = {}
+    fwd_base_identities = {}
+    rev_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
+        total_reads = bam.mapped
+        for read in tqdm(bam.fetch(chromosome), desc='Extracting base identities from reads in BAM', total=total_reads):  
+            # Only iterate over mapped reads
+            if read.is_mapped:
+                # Get sequence of read. PySam reports fwd mapped reads as the true read sequence. Pysam reports rev mapped reads as the reverse complement of the read.
+                query_sequence = read.query_sequence
+                # If the read aligned as a reverse complement, mark that the read is reversed
+                if read.is_reverse:
+                    # Initialize the read key in a temp base_identities dictionary by pointing to a N filled list of length reference_length.
+                    rev_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.query_sequence start, as well the 0-based index relative to the reference.
+                    for read_position, reference_position in read.get_aligned_pairs(matches_only=True):
+                        # 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
+                            rev_base_identities[read.query_name][reference_position] = query_sequence[read_position]
+                else:
+                    # Initialize the read key in a temp base_identities dictionary by pointing to a N filled list of length reference_length.
+                    fwd_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.query_sequence start, as well the 0-based index relative to the reference.
+                    for read_position, reference_position in read.get_aligned_pairs(matches_only=True):
+                        # 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
+                            fwd_base_identities[read.query_name][reference_position] = query_sequence[read_position]
+
+    return fwd_base_identities, rev_base_identities

smftools/informatics/helpers/extract_mods.py

@@ -1,13 +1,25 @@
 ## extract_mods
-import os
-import subprocess
-import glob
-import zipfile
 
 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}"))
@@ -23,7 +35,7 @@ def extract_mods(thresholds, mod_tsv_dir, split_dir, bam_suffix):
         # Run modkit extract
         subprocess.run([
             "modkit", "extract",
-            "--filter-threshold", filter_threshold,
+            "--filter-threshold", f'{filter_threshold}',
             "--mod-thresholds", f"m:{m5C_threshold}",
             "--mod-thresholds", f"a:{m6A_threshold}",
             "--mod-thresholds", f"h:{hm5C_threshold}",

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

@@ -1,33 +1,40 @@
 ## find_conversion_sites
-from .. import readwrite
-# bioinformatic operations
-from Bio import SeqIO
-from Bio.SeqRecord import SeqRecord
-from Bio.Seq import Seq
 
-def find_conversion_sites(fasta_file, modification_type):
+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.
-    Input: A FASTA file and the modification_types of interest
+
+    Parameters:
+        fasta_file (str): A string representing the file path to the converted 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: 
-    A dictionary called record_dict, which is 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
+        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, 5) Complement sequence
     """
-    print('{0}: Finding positions of interest in reference FASTA > {1}'.format(readwrite.time_string(), fasta_file))
+    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))
+    #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))
+            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()
+                complement = str(record.seq.complement()).upper()
                 sequence_length = len(sequence)
                 if modification_type == '5mC':
                     # Iterate over the sequence string from the record
@@ -36,7 +43,7 @@ def find_conversion_sites(fasta_file, modification_type):
                             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()))
+                    #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)):
@@ -44,10 +51,11 @@ def find_conversion_sites(fasta_file, modification_type):
                             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()))          
+                    #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]
+                    #print('modification_type not found. Please try 5mC or 6mA') 
+                    pass   
+                record_dict[record.id] = [sequence_length, top_strand_coordinates, bottom_strand_coordinates, sequence, complement]
             else:
                 pass  
     return record_dict

smftools/informatics/helpers/generate_converted_FASTA.py

@@ -1,14 +1,16 @@
 ## generate_converted_FASTA
-from .. import readwrite
-# bioinformatic operations
-from Bio import SeqIO
-from Bio.SeqRecord import SeqRecord
-from Bio.Seq import Seq
 
-def convert_FASTA_record(record, modification_type, strand):
+def convert_FASTA_record(record, modification_type, strand, unconverted):
     """
-    Input: Takes a FASTA record, modification type, and strand as input
-    Output: Returns a new seqrecord object with the conversions of interest
+    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':
@@ -18,7 +20,8 @@ def convert_FASTA_record(record, modification_type, strand):
             # 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')        
+            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
@@ -28,32 +31,68 @@ def convert_FASTA_record(record, modification_type, strand):
             new_seq = record.seq.upper().replace('T', 'C')
         else:
             print('need to provide a valid strand string: top or bottom')
-    elif modification_type == 'unconverted':
+        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('need to provide a valid modification_type string: 5mC, 6mA, or unconverted')   
-    new_id = '{0}_{1}_{2}'.format(record.id, modification_type, strand)      
-    # Return a new SeqRecord with modified sequence and ID
+        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):
     """
-    Input: Takes an input FASTA, modification types of interest, strands of interest, and an output FASTA name 
-    Output: Writes out a new fasta with all stranded conversions
-    Notes: Uses modify_sequence_and_id function on every record within the 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.
     """
-    with open(output_fasta, 'w') as output_handle:
-        modified_records = []
-        # Iterate over each record in the input FASTA
+    from .. import readwrite
+    from Bio import SeqIO
+    from Bio.SeqRecord import SeqRecord
+    from Bio.Seq import Seq
+    import gzip
+    modified_records = []
+    unconverted = modification_types[0]
+    # Iterate over each record in the input FASTA
+    if '.gz' in input_fasta:
+        with gzip.open(input_fasta, 'rt') as handle:    
+            for record in SeqIO.parse(handle, '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)
+    else:
         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 only is added once and takes on the strand that is provided at the 0 index on 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}')
-                        modified_records.append(convert_FASTA_record(record, modification_type, strand))
+                        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_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

@@ -1,17 +1,20 @@
 ## get_native_references
-from .. import readwrite
-# bioinformatic operations
-from Bio import SeqIO
-from Bio.SeqRecord import SeqRecord
-from Bio.Seq import Seq
 
 # Direct methylation specific
 def get_native_references(fasta_file):
     """
-    Input: A 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: 
-    A dictionary called record_dict, which is keyed by record ids contained within the FASTA. Points to a list containing: 1) sequence length of the record, 2) sequence of the record
+        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

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

@@ -1,12 +1,18 @@
 ## make_dirs
-import os
 
 # General
 def make_dirs(directories):
     """
-    Input: Takes a list of file paths to make directories for
-    Output: Makes each directory in the list if the directory doesn't already exist.
+    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)

smftools/informatics/helpers/make_modbed.py

@@ -1,19 +1,25 @@
 ## make_modbed
-import os
-import subprocess
 
 # Direct SMF
 def make_modbed(aligned_sorted_output, thresholds, mod_bed_dir):
     """
-    Generating Barcode position methylation summaries starting from the overall BAM file that was direct output of dorado aligner
+    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", filter_threshold,
+        "--filter-threshold", f'{filter_threshold}',
         "--mod-thresholds", f"m:{m5C_threshold}",
         "--mod-thresholds", f"a:{m6A_threshold}",
         "--mod-thresholds", f"h:{hm5C_threshold}"

smftools/informatics/helpers/modQC.py

@@ -1,17 +1,25 @@
 ## modQC
-import subprocess
 
 # 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", filter_threshold,
+        "--filter-threshold", f"{filter_threshold}",
         "--mod-thresholds", f"m:{m5C_threshold}",
         "--mod-thresholds", f"a:{m6A_threshold}",
         "--mod-thresholds", f"h:{hm5C_threshold}"

smftools/informatics/helpers/modcall.py

@@ -1,14 +1,28 @@
 ## modcall
-import subprocess
 
 # 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
+    "--modified-bases"]
+    command += mod_list
+    print(f'Running: {" ".join(command)}')
     with open(output, "w") as outfile:
         subprocess.run(command, stdout=outfile)