smftools 0.1.0__py3-none-any.whl

smftools/__init__.py

@@ -0,0 +1,27 @@
+"""smftools"""
+
+import logging
+import warnings
+
+from anndata import AnnData
+from . import informatics as inform
+from . import preprocessing as pp
+from . import tools as tl
+from . import plotting as pl
+from . import readwrite, datasets
+
+
+from importlib.metadata import version
+
+package_name = "smftools"
+__version__ = version(package_name)
+
+__all__ = [
+    "AnnData",
+    "inform",
+    "pp",
+    "tl",
+    "pl",
+    "readwrite",
+    "datasets"
+]

smftools/_settings.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+
+class SMFConfig:
+    """\
+    Config for smftools.
+    """
+
+    def __init__(
+        self,
+        *,
+        datasetdir: Path | str = "./datasets/"
+    ):
+        self.datasetdir = datasetdir
+
+    @property
+    def datasetdir(self) -> Path:
+        return self._datasetdir
+
+settings = SMFConfig()

smftools/datasets/__init__.py

@@ -0,0 +1,9 @@
+from .datasets import (
+    dCas9_kinetics,
+    Kissiov_and_McKenna_2025
+)
+
+__all__ = [
+    "dCas9_kinetics",
+    "Kissiov_and_McKenna_2025"
+]

smftools/datasets/datasets.py

@@ -0,0 +1,25 @@
+## datasets
+
+import numpy as np
+import pandas as pd
+import anndata as ad
+from pathlib import Path
+
+from .._settings import settings
+
+HERE = Path(__file__).parent
+
+
+def dCas9_kinetics():
+    """
+    
+    """
+    filepath = HERE / "dCas9_m6A_invitro_kinetics.h5ad.gz"
+    return ad.read_h5ad(filepath)
+
+def Kissiov_and_McKenna_2025():
+    """
+    
+    """
+    filepath = HERE / "F1_hybrid_NKG2A_enhander_promoter_GpC_conversion_SMF.h5ad.gz"
+    return ad.read_h5ad(filepath)

smftools/informatics/__init__.py

@@ -0,0 +1,11 @@
+from . import helpers
+from .pod5_conversion import pod5_conversion
+from .pod5_direct import pod5_direct
+from .pod5_to_adata import pod5_to_adata
+
+__all__ = [
+    "helpers",
+    "pod5_conversion",
+    "pod5_direct"
+    "pod5_to_adata"
+]

smftools/informatics/helpers/__init__.py

@@ -0,0 +1,42 @@
+from .align_BAM import align_BAM
+from .binarize_converted_base_identities import binarize_converted_base_identities
+from .canoncall import canoncall
+from .converted_BAM_to_adata import converted_BAM_to_adata
+from .count_aligned_reads import count_aligned_reads
+from .extract_base_identities import extract_base_identities
+from .extract_mods import extract_mods
+from .find_conversion_sites import find_conversion_sites
+from .generate_converted_FASTA import convert_FASTA_record, generate_converted_FASTA
+from .get_native_references import get_native_references
+from .load_experiment_config import load_experiment_config
+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 .separate_bam_by_bc import separate_bam_by_bc
+from .split_and_index_BAM import split_and_index_BAM
+
+__all__ = [
+    "align_BAM",
+    "binarize_converted_base_identities",
+    "canoncall",
+    "converted_BAM_to_adata",
+    "count_aligned_reads",
+    "extract_base_identities",
+    "extract_mods",
+    "find_conversion_sites",
+    "convert_FASTA_record",
+    "generate_converted_FASTA",
+    "get_native_references",
+    "load_experiment_config",
+    "make_dirs",
+    "make_modbed",
+    "modcall",
+    "modkit_extract_to_adata",
+    "modQC",
+    "one_hot_encode",
+    "separate_bam_by_bc",
+    "split_and_index_BAM"
+]

smftools/informatics/helpers/align_BAM.py

@@ -0,0 +1,49 @@
+## align_BAM
+import subprocess
+
+def align_BAM(fasta, bam, bam_suffix):
+    """
+    A wrapper for running dorado aligner and samtools functions
+    """
+    aligned_BAM=f"{bam}_aligned"
+    aligned_sorted_BAM=f"{aligned_BAM}_sorted"
+    output = bam + bam_suffix
+    aligned_output = aligned_BAM + bam_suffix
+    aligned_sorted_output = aligned_sorted_BAM + bam_suffix
+    
+    # Run dorado aligner
+    subprocess.run([
+        "dorado", "aligner",
+        "--secondary=no",
+        fasta,
+        output
+    ], stdout=open(aligned_output, "w"))
+
+    # Sort the BAM on positional coordinates
+    subprocess.run([
+        "samtools", "sort",
+        "-o", aligned_sorted_output,
+        aligned_output
+    ])
+
+    # Create a BAM index file
+    subprocess.run([
+        "samtools", "index",
+        aligned_sorted_output
+    ])
+
+    # Make a bed file of coordinates for the BAM
+    subprocess.run([
+        "samtools", "view",
+        aligned_sorted_output
+    ], stdout=subprocess.PIPE) | subprocess.run([
+        "awk", '{print $3, $4, $4+length($10)-1}'
+    ], stdin=subprocess.PIPE, stdout=open(f"{aligned_sorted_BAM}_bed.bed", "w"))
+
+    # Make a text file of reads for the BAM
+    subprocess.run([
+        "samtools", "view",
+        aligned_sorted_output
+    ], stdout=subprocess.PIPE) | subprocess.run([
+        "cut", "-f1"
+    ], stdin=subprocess.PIPE, stdout=open(f"aligned_sorted_BAM_read_names.txt", "w"))

smftools/informatics/helpers/binarize_converted_base_identities.py

@@ -0,0 +1,24 @@
+## binarize_converted_base_identities
+import numpy as np
+# 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

smftools/informatics/helpers/canoncall.py

@@ -0,0 +1,12 @@
+## canoncall
+import subprocess
+
+# Conversion SMF specific
+def canoncall(model, pod5_dir, barcode_kit, bam, bam_suffix):
+    """
+    Wrapper function for dorado canonical base calling.
+    """
+    output = bam + bam_suffix
+    command = ["dorado", "basecaller", model, pod5_dir, "--kit-name", barcode_kit, "-Y"]
+    with open(output, "w") as outfile:
+        subprocess.run(command, stdout=outfile)

smftools/informatics/helpers/converted_BAM_to_adata.py

@@ -0,0 +1,147 @@
+## converted_BAM_to_adata
+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
+
+def converted_BAM_to_adata(converted_FASTA, split_dir, mapping_threshold, experiment_name, conversion_types, bam_suffix):
+    """
+    
+    """
+    # 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)
+        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]
+
+    # 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)
+        record_FASTA_dict = {}
+        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 = chromosome + '_unconverted_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)
+        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

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

@@ -0,0 +1,36 @@
+## 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.
+    """
+    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

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

@@ -0,0 +1,53 @@
+## 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):
+    """
+    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(readwrite.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(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

@@ -0,0 +1,59 @@
+## 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):
+    """
+    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
+
+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(convert_FASTA_record(record, modification_type, strand))
+        # write out the concatenated FASTA file of modified sequences
+        SeqIO.write(modified_records, output_handle, 'fasta')

smftools/informatics/helpers/get_native_references.py

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