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

smftools/informatics/basecall_pod5s.py

@@ -0,0 +1,80 @@
+# basecall_pod5s
+
+def basecall_pod5s(config_path):
+    """
+    Basecall from pod5s given a config file.
+
+    Parameters:
+        config_path (str): File path to the basecall configuration file
+
+    Returns:
+        None
+    """
+    # Lazy importing of packages
+    from .helpers import LoadExperimentConfig, make_dirs, canoncall, modcall
+    from .fast5_to_pod5 import fast5_to_pod5
+    import os
+    from pathlib import Path
+
+    # Default params
+    bam_suffix = '.bam' # If different, change from here.
+
+    # Load experiment config parameters into global variables
+    experiment_config = LoadExperimentConfig(config_path)
+    var_dict = experiment_config.var_dict
+
+    # These below variables will point to default_value if they are empty in the experiment_config.csv or if the variable is fully omitted from the csv.
+    default_value = None
+
+    # General config variable init
+    input_data_path = var_dict.get('input_data_path', default_value) # Path to a directory of POD5s/FAST5s or to a BAM/FASTQ file. Necessary.
+    output_directory = var_dict.get('output_directory', default_value) # Path to the output directory to make for the analysis. Necessary.
+    model = var_dict.get('model', default_value) # needed for dorado basecaller
+    barcode_kit = var_dict.get('barcode_kit', default_value) # needed for dorado basecaller
+    barcode_both_ends = var_dict.get('barcode_both_ends', default_value) # dorado demultiplexing
+    trim = var_dict.get('trim', default_value) # dorado adapter and barcode removal
+    device = var_dict.get('device', 'auto')
+
+    # Modified basecalling specific variable init
+    filter_threshold = var_dict.get('filter_threshold', default_value)
+    m6A_threshold = var_dict.get('m6A_threshold', default_value)
+    m5C_threshold = var_dict.get('m5C_threshold', default_value)
+    hm5C_threshold = var_dict.get('hm5C_threshold', default_value)
+    thresholds = [filter_threshold, m6A_threshold, m5C_threshold, hm5C_threshold]
+    mod_list = var_dict.get('mod_list', default_value)
+    
+    # Make initial output directory
+    make_dirs([output_directory])
+    os.chdir(output_directory)
+
+    # Get the input filetype
+    if Path(input_data_path).is_file():
+        input_data_filetype = '.' + os.path.basename(input_data_path).split('.')[1].lower()
+        input_is_pod5 = input_data_filetype in ['.pod5','.p5']
+        input_is_fast5 = input_data_filetype in ['.fast5','.f5']
+
+    elif Path(input_data_path).is_dir():
+        # Get the file names in the input data dir
+        input_files = os.listdir(input_data_path)
+        input_is_pod5 = sum([True for file in input_files if '.pod5' in file or '.p5' in file])
+        input_is_fast5 = sum([True for file in input_files if '.fast5' in file or '.f5' in file])
+
+    # If the input files are not pod5 files, and they are fast5 files, convert the files to a pod5 file before proceeding.
+    if input_is_fast5 and not input_is_pod5:
+        # take the input directory of fast5 files and write out a single pod5 file into the output directory.
+        output_pod5 = os.path.join(output_directory, 'FAST5s_to_POD5.pod5')
+        print(f'Input directory contains fast5 files, converting them and concatenating into a single pod5 file in the {output_pod5}')
+        fast5_to_pod5(input_data_path, output_pod5)
+        # Reassign the pod5_dir variable to point to the new pod5 file.
+        input_data_path = output_pod5
+
+    model_basename = os.path.basename(model)
+    model_basename = model_basename.replace('.', '_')
+
+    if mod_list:
+        mod_string = "_".join(mod_list)
+        bam=f"{output_directory}/{model_basename}_{mod_string}_calls"
+        modcall(model, input_data_path, barcode_kit, mod_list, bam, bam_suffix, barcode_both_ends, trim, device)
+    else:
+        bam=f"{output_directory}/{model_basename}_canonical_basecalls"
+        canoncall(model, input_data_path, barcode_kit, bam, bam_suffix, barcode_both_ends, trim, device)

smftools/informatics/fast5_to_pod5.py

@@ -0,0 +1,24 @@
+# fast5_to_pod5
+
+def fast5_to_pod5(fast5_dir, output_pod5='FAST5s_to_POD5.pod5'):
+    """
+    Convert Nanopore FAST5 files to POD5 file
+
+    Parameters:
+        fast5_dir (str): String representing the file path to a directory containing all FAST5 files to convert into a single POD5 output.
+        output_pod5 (str): The name of the output POD5.
+    
+    Returns:
+        None
+    
+    """
+    import subprocess
+    from pathlib import Path
+
+    if isinstance(fast5_dir, (list, tuple)):
+        cmd = ["pod5", "convert", "fast5"] + fast5_dir + ["--output", output_pod5]
+        subprocess.run(cmd)
+    elif Path(fast5_dir).is_file():
+        subprocess.run(["pod5", "convert", "fast5", fast5_dir, "--output", output_pod5])
+    elif Path(fast5_dir).is_dir():
+        subprocess.run(["pod5", "convert", "fast5", f".{fast5_dir}*.fast5", "--output", output_pod5])

smftools/informatics/helpers/__init__.py

@@ -0,0 +1,73 @@
+from .align_and_sort_BAM import align_and_sort_BAM
+from .aligned_BAM_to_bed import aligned_BAM_to_bed
+from .bam_qc import bam_qc
+from .bed_to_bigwig import bed_to_bigwig
+from .binarize_converted_base_identities import binarize_converted_base_identities
+from .canoncall import canoncall
+from .complement_base_list import complement_base_list
+from .converted_BAM_to_adata_II import converted_BAM_to_adata_II
+from .concatenate_fastqs_to_bam import concatenate_fastqs_to_bam
+from .count_aligned_reads import count_aligned_reads
+from .demux_and_index_BAM import demux_and_index_BAM
+from .discover_input_files import *
+from .extract_base_identities import extract_base_identities
+from .extract_mods import extract_mods
+from .extract_read_features_from_bam import extract_read_features_from_bam
+from .extract_read_lengths_from_bed import extract_read_lengths_from_bed
+from .extract_readnames_from_BAM import extract_readnames_from_BAM
+from .find_conversion_sites import find_conversion_sites
+from .generate_converted_FASTA import convert_FASTA_record, generate_converted_FASTA
+from .get_chromosome_lengths import get_chromosome_lengths
+from .get_native_references import get_native_references
+from .index_fasta import index_fasta
+from .make_dirs import make_dirs
+from .make_modbed import make_modbed
+from .modcall import modcall
+from .modkit_extract_to_adata import modkit_extract_to_adata
+from .modQC import modQC
+from .one_hot_encode import one_hot_encode
+from .ohe_batching import ohe_batching
+from .one_hot_decode import one_hot_decode
+from .ohe_layers_decode import ohe_layers_decode
+from .plot_bed_histograms import plot_bed_histograms
+from .run_multiqc import run_multiqc
+from .separate_bam_by_bc import separate_bam_by_bc
+from .split_and_index_BAM import split_and_index_BAM
+
+__all__ = [
+    "align_and_sort_BAM",
+    "aligned_BAM_to_bed",
+    "bam_qc",
+    "bed_to_bigwig",
+    "binarize_converted_base_identities",
+    "canoncall",
+    "complement_base_list",
+    "converted_BAM_to_adata_II",
+    "concatenate_fastqs_to_bam",
+    "count_aligned_reads",
+    "demux_and_index_BAM",
+    "extract_base_identities",
+    "extract_mods",
+    "extract_read_features_from_bam",
+    "extract_read_lengths_from_bed",
+    "extract_readnames_from_BAM",
+    "find_conversion_sites",
+    "convert_FASTA_record",
+    "generate_converted_FASTA",
+    "get_chromosome_lengths",
+    "get_native_references",
+    "index_fasta",
+    "make_dirs",
+    "make_modbed",
+    "modcall",
+    "modkit_extract_to_adata",
+    "modQC",
+    "one_hot_encode",
+    "ohe_batching",
+    "one_hot_decode",
+    "ohe_layers_decode",
+    "plot_bed_histograms",
+    "run_multiqc",
+    "separate_bam_by_bc",
+    "split_and_index_BAM"
+]

smftools/informatics/helpers/align_and_sort_BAM.py

@@ -0,0 +1,86 @@
+## align_and_sort_BAM
+
+def align_and_sort_BAM(fasta, 
+                       input, 
+                       bam_suffix='.bam', 
+                       output_directory='aligned_outputs', 
+                       make_bigwigs=False, 
+                       threads=None, 
+                       aligner='minimap2',
+                       aligner_args=['-a', '-x', 'map-ont', '--MD', '-Y', '-y', '-N', '5', '--secondary=no']):
+    """
+    A wrapper for running dorado aligner and samtools functions
+    
+    Parameters:
+        fasta (str): File path to the reference genome to align to.
+        input (str): File path to the basecalled file to align. Works for .bam and .fastq files
+        bam_suffix (str): The suffix to use for the BAM file.
+        output_directory (str): A file path to the directory to output all the analyses.
+        make_bigwigs (bool): Whether to make bigwigs
+        threads (int): Number of additional threads to use
+        aligner (str): Aligner to use. minimap2 and dorado options
+        aligner_args (list): list of optional parameters to use for the alignment
+
+    Returns:
+        None
+            The function writes out files for: 1) An aligned BAM, 2) and aligned_sorted BAM, 3) an index file for the aligned_sorted BAM, 4) A bed file for the aligned_sorted BAM, 5) A text file containing read names in the aligned_sorted BAM
+    """
+    import subprocess
+    import os
+
+    input_basename = os.path.basename(input)
+    input_suffix = '.' + input_basename.split('.')[1]
+    input_as_fastq = input_basename.split('.')[0] + '.fastq'
+
+    output_path_minus_suffix = os.path.join(output_directory, input_basename.split(input_suffix)[0])
+    
+    aligned_BAM=f"{output_path_minus_suffix}_aligned"
+    aligned_sorted_BAM=f"{aligned_BAM}_sorted"
+    aligned_output = aligned_BAM + bam_suffix
+    aligned_sorted_output = aligned_sorted_BAM + bam_suffix
+
+    if threads:
+        threads = str(threads)
+    else:
+        pass
+    
+    if aligner == 'minimap2':
+        print(f"Converting BAM to FASTQ: {input}")
+        bam_to_fastq_command = ['samtools', 'fastq', input]
+        subprocess.run(bam_to_fastq_command, stdout=open(input_as_fastq, "w"))
+        print(f"Aligning FASTQ to Reference: {input_as_fastq}")
+        if threads:
+            minimap_command = ['minimap2'] + aligner_args + ['-t', threads, fasta, input_as_fastq]
+        else:
+            minimap_command = ['minimap2'] + aligner_args + [fasta, input_as_fastq]
+        subprocess.run(minimap_command, stdout=open(aligned_output, "w"))
+        os.remove(input_as_fastq)
+
+    elif aligner == 'dorado':
+        # Run dorado aligner
+        print(f"Aligning BAM to Reference: {input}")
+        if threads:
+            alignment_command = ["dorado", "aligner", "-t", threads] + aligner_args + [fasta, input]
+        else:
+            alignment_command = ["dorado", "aligner"] + aligner_args + [fasta, input]
+        subprocess.run(alignment_command, stdout=open(aligned_output, "w"))
+
+    else:
+        print(f'Aligner not recognized: {aligner}. Choose from minimap2 and dorado')
+        return
+
+    # Sort the BAM on positional coordinates
+    print(f"Sorting BAM: {aligned_output}")
+    if threads:
+        sort_command = ["samtools", "sort", "-@", threads, "-o", aligned_sorted_output, aligned_output]
+    else:
+        sort_command = ["samtools", "sort", "-o", aligned_sorted_output, aligned_output]
+    subprocess.run(sort_command)
+
+    # Create a BAM index file
+    print(f"Indexing BAM: {aligned_sorted_output}")
+    if threads:
+        index_command = ["samtools", "index", "-@", threads, aligned_sorted_output]
+    else:
+        index_command = ["samtools", "index", aligned_sorted_output]
+    subprocess.run(index_command)

smftools/informatics/helpers/aligned_BAM_to_bed.py

@@ -0,0 +1,85 @@
+def aligned_BAM_to_bed(aligned_BAM, out_dir, fasta, make_bigwigs, threads=None):
+    """
+    Takes an aligned BAM as input and writes a BED file of reads as output.
+    Bed columns are: Record name, start position, end position, read length, read name, mapping quality, read quality.
+
+    Parameters:
+        aligned_BAM (str): Path to an input aligned_BAM to extract to a BED file.
+        out_dir (str): Directory to output files.
+        fasta (str): File path to the reference genome.
+        make_bigwigs (bool): Whether to generate bigwig files.
+        threads (int): Number of threads to use.
+
+    Returns:
+        None
+    """
+    import subprocess
+    import os
+    import pysam
+    import numpy as np
+    import concurrent.futures
+    from concurrent.futures import ProcessPoolExecutor
+    from .bed_to_bigwig import bed_to_bigwig
+    from . import make_dirs
+    from .plot_bed_histograms import plot_bed_histograms
+
+    threads = threads or os.cpu_count()  # Use max available cores if not specified
+
+    # Create necessary directories
+    plotting_dir = os.path.join(out_dir, "bed_cov_histograms")
+    bed_dir = os.path.join(out_dir, "beds")
+    make_dirs([plotting_dir, bed_dir])
+
+    bed_output = os.path.join(bed_dir, os.path.basename(aligned_BAM).replace(".bam", "_bed.bed"))
+
+    print(f"Creating BED-like file from BAM (with MAPQ and avg base quality): {aligned_BAM}")
+
+    with pysam.AlignmentFile(aligned_BAM, "rb") as bam, open(bed_output, "w") as out:
+        for read in bam.fetch(until_eof=True):
+            if read.is_unmapped:
+                chrom = "*"
+                start1 = 1
+                rl = read.query_length or 0
+                mapq = 0
+            else:
+                chrom = bam.get_reference_name(read.reference_id)
+                # pysam reference_start is 0-based → +1 for 1-based SAM-like start
+                start1 = int(read.reference_start) + 1
+                rl = read.query_length or 0
+                mapq = int(read.mapping_quality)
+
+            # End position in 1-based inclusive coords
+            end1 = start1 + (rl or 0) - 1
+
+            qname = read.query_name
+            quals = read.query_qualities
+            if quals is None or rl == 0:
+                avg_q = float("nan")
+            else:
+                avg_q = float(np.mean(quals))
+
+            out.write(f"{chrom}\t{start1}\t{end1}\t{rl}\t{qname}\t{mapq}\t{avg_q:.3f}\n")
+
+    print(f"BED-like file created: {bed_output}")
+
+    def split_bed(bed):
+        """Splits into aligned and unaligned reads (chrom == '*')."""
+        aligned = bed.replace(".bed", "_aligned.bed")
+        unaligned = bed.replace(".bed", "_unaligned.bed")
+        with open(bed, "r") as infile, open(aligned, "w") as aligned_out, open(unaligned, "w") as unaligned_out:
+            for line in infile:
+                (unaligned_out if line.startswith("*\t") else aligned_out).write(line)
+        os.remove(bed)
+        return aligned
+
+    print(f"Splitting: {bed_output}")
+    aligned_bed = split_bed(bed_output)
+
+    with ProcessPoolExecutor() as executor:
+        futures = []
+        futures.append(executor.submit(plot_bed_histograms, aligned_bed, plotting_dir, fasta))
+        if make_bigwigs:
+            futures.append(executor.submit(bed_to_bigwig, fasta, aligned_bed))
+        concurrent.futures.wait(futures)
+
+    print("Processing completed successfully.")

smftools/informatics/helpers/archived/informatics.py

@@ -0,0 +1,260 @@
+## fasta_module
+from .. import readwrite
+# bioinformatic operations
+from Bio import SeqIO
+from Bio.SeqRecord import SeqRecord
+from Bio.Seq import Seq
+import pysam
+
+######################################################################################################
+## FASTA functionality
+# General
+
+# Conversion specific
+def modify_sequence_and_id(record, modification_type, strand):
+    """
+    Input: Takes a FASTA record, modification type, and strand as input
+    Output: Returns a new seqrecord object with the conversions of interest
+    """
+    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')        
+    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')
+    elif modification_type == 'unconverted':
+        new_seq = record.seq.upper()
+    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
+    return record.__class__(new_seq, id=new_id, description=record.description)
+
+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
+    """
+    with open(output_fasta, 'w') as output_handle:
+        modified_records = []
+        # Iterate over each record in the input FASTA
+        for record in SeqIO.parse(input_fasta, 'fasta'):
+            # 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.
+                        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(modify_sequence_and_id(record, modification_type, strand))
+        # write out the concatenated FASTA file of modified sequences
+        SeqIO.write(modified_records, output_handle, 'fasta')
+
+def find_coordinates(fasta_file, modification_type):
+    """
+    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
+    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
+    """
+    print('{0}: Finding positions of interest in reference FASTA > {1}'.format(time_string(), fasta_file))
+    # Initialize lists to hold top and bottom strand positional coordinates of interest
+    top_strand_coordinates = []
+    bottom_strand_coordinates = []
+    record_dict = {}
+    print('{0}: Opening FASTA file {1}'.format(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(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(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(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
+
+# Direct methylation specific
+def get_references(fasta_file):
+    """
+    Input: A FASTA file
+    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
+    """
+    record_dict = {}
+    print('{0}: Opening FASTA file {1}'.format(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
+######################################################################################################
+
+######################################################################################################
+## BAM functionality
+# General
+def separate_bam_by_bc(input_bam, output_prefix):
+    """
+    Input: Takes a single BAM input. Also takes an output prefix to append to the output file.
+    Output: Splits the BAM based on the BC SAM tag value.
+    """
+    # Open the input BAM file for reading
+    with pysam.AlignmentFile(input_bam, "rb") as bam:
+        # Create a dictionary to store output BAM files
+        output_files = {}
+        # Iterate over each read in the BAM file
+        for read in bam:
+            try:
+                # Get the barcode tag value
+                bc_tag = read.get_tag("BC", with_value_type=True)[0].split('barcode')[1]
+                # Open the output BAM file corresponding to the barcode
+                if bc_tag not in output_files:
+                    output_files[bc_tag] = pysam.AlignmentFile(f"{output_prefix}_{bc_tag}.bam", "wb", header=bam.header)
+                # Write the read to the corresponding output BAM file
+                output_files[bc_tag].write(read)
+            except KeyError:
+                 print(f"BC tag not present for read: {read.query_name}")
+    # Close all output BAM files
+    for output_file in output_files.values():
+        output_file.close()
+
+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
+    """
+    print('{0}: Counting aligned reads in BAM > {1}'.format(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
+
+def extract_base_identity_at_coordinates(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.
+    """
+    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(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(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
+
+# Conversion SMF specific
+def binarize_converted_base_identities(base_identities, strand, modification_type):
+    """
+    Input: The base identities dictionary returned by extract_base_identity_at_coordinates.
+    Output: A binarized format of the dictionary, where 1 represents a methylated site. 0 represents an unmethylated site. NaN represents a site that does not carry SMF information.
+    """
+    binarized_base_identities = {}
+    # Iterate over base identity keys to binarize the base identities
+    for key in base_identities.keys():
+        if strand == 'top':
+            if modification_type == '5mC':
+                binarized_base_identities[key] = [1 if x == 'C' else 0 if x == 'T' else np.nan for x in base_identities[key]]
+            elif modification_type == '6mA':
+                binarized_base_identities[key] = [1 if x == 'A' else 0 if x == 'G' else np.nan for x in base_identities[key]]
+        elif strand == 'bottom':
+            if modification_type == '5mC':
+                binarized_base_identities[key] = [1 if x == 'G' else 0 if x == 'A' else np.nan for x in base_identities[key]]
+            elif modification_type == '6mA':
+                binarized_base_identities[key] = [1 if x == 'T' else 0 if x == 'C' else np.nan for x in base_identities[key]]
+        else:
+            pass
+    return binarized_base_identities
+
+# Direct methylation specific
+
+######################################################################################################
+
+######################################################################################################
+# String encodings
+def one_hot_encode(sequence):
+    """
+    Input: A sequence string of a read.
+    Output: One hot encoding of the sequence string.
+    """
+    mapping = {'A': 0, 'C': 1, 'G': 2, 'T': 3, 'N': 4}
+    one_hot_matrix = np.zeros((len(sequence), 5), dtype=int)
+    for i, nucleotide in enumerate(sequence):
+        one_hot_matrix[i, mapping[nucleotide]] = 1
+    return one_hot_matrix
+######################################################################################################