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

smftools/informatics/helpers/ohe_batching.py

@@ -0,0 +1,52 @@
+# ohe_batching
+
+def ohe_batching(base_identities, tmp_dir, record, prefix='', batch_size=100000):
+    """
+    Processes base identities to one-hot encoded matrices and writes to a h5ad file in batches.
+
+    Parameters:
+        base_identities (dict): A dictionary of read names and sequences.
+        tmp_dir (str): Path to directory where the files will be saved.
+        record (str): Name of the record.
+        prefix (str): Prefix to add to the output file name
+        batch_size (int): Number of reads to process in each batch.
+
+    Returns:
+        ohe_file (list): list of output file names
+    """
+    import os
+    import anndata as ad
+    import numpy as np
+    from tqdm import tqdm
+    from .one_hot_encode import one_hot_encode
+
+    batch = {}
+    count = 0
+    batch_number = 0
+    total_reads = len(base_identities)
+    file_names = []
+    
+    for read_name, seq in tqdm(base_identities.items(), desc="Encoding and writing one hot encoded reads", total=total_reads):
+        one_hot_matrix = one_hot_encode(seq)
+        batch[read_name] = one_hot_matrix
+        count += 1
+        # If the batch size is reached, write out the batch and reset
+        if count >= batch_size:
+            save_name = os.path.join(tmp_dir, f'tmp_{prefix}_{record}_{batch_number}.h5ad.gz')
+            X = np.random.rand(1, 1)
+            tmp_ad = ad.AnnData(X=X, uns=batch) 
+            tmp_ad.write_h5ad(save_name, compression='gzip')
+            file_names.append(save_name)
+            batch.clear()
+            count = 0
+            batch_number += 1
+
+    # Write out any remaining reads in the final batch
+    if batch:
+        save_name = os.path.join(tmp_dir, f'tmp_{prefix}_{record}_{batch_number}.h5ad.gz')
+        X = np.random.rand(1, 1)
+        tmp_ad = ad.AnnData(X=X, uns=batch) 
+        tmp_ad.write_h5ad(save_name, compression='gzip')
+        file_names.append(save_name)
+
+    return file_names

smftools/informatics/helpers/one_hot_encode.py

@@ -3,17 +3,19 @@
 # String encodings
 def one_hot_encode(sequence):
     """
-    One hot encodes a sequence string.
+    One hot encodes a sequence list.
     Parameters:
-        sequence (str): A DNA sequence string.
+        sequence (list): A list of DNA base sequences.
 
     Returns:
-        one_hot_matrix (ndarray): A numpy ndarray holding a vstacked one hot encoding of the input sequence string.
+        flattened (ndarray): A numpy ndarray holding a flattened one hot encoding of the input sequence string.
     """
     import numpy as np
 
-    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
+    seq_array = np.array(sequence, dtype='<U1')  # String dtype
+    mapping = np.array(['A', 'C', 'G', 'T', 'N'])
+    seq_array[~np.isin(seq_array, mapping)] = 'N'
+    one_hot_matrix = (seq_array[:, None] == mapping).astype(int)
+    flattened = one_hot_matrix.flatten()
+
+    return flattened

smftools/informatics/helpers/plot_read_length_and_coverage_histograms.py

@@ -0,0 +1,52 @@
+# plot_read_length_and_coverage_histograms
+
+def plot_read_length_and_coverage_histograms(bed_file, plotting_directory):
+    """
+    Plots read length and coverage statistics for each record.
+
+    Parameters:
+        bed_file (str): Path to the bed file to derive read lengths and coverage from.
+        plot_directory (str): Path to the directory to write out historgrams.
+
+    Returns:
+        None
+    """
+    import pandas as pd
+    import matplotlib.pyplot as plt
+    import numpy as np
+    import os
+
+    bed_basename = os.path.basename(bed_file).split('.bed')[0]
+    # Load the BED file into a DataFrame
+    df = pd.read_csv(bed_file, sep='\t', header=None, names=['chromosome', 'start', 'end', 'length', 'read_name'])
+    
+    # Group by chromosome
+    grouped = df.groupby('chromosome')
+
+    for chrom, group in grouped:
+        # Plot read length histogram
+        plt.figure(figsize=(12, 6))
+        plt.hist(group['length'], bins=50, edgecolor='k', alpha=0.7)
+        plt.title(f'Read Length Histogram of reads aligned to {chrom}')
+        plt.xlabel('Read Length')
+        plt.ylabel('Count')
+        plt.grid(True)
+        save_name = os.path.join(plotting_directory, f'{bed_basename}_{chrom}_read_length_histogram.png')
+        plt.savefig(save_name)
+        plt.close()
+
+        # Compute coverage
+        coverage = np.zeros(group['end'].max())
+        for _, row in group.iterrows():
+            coverage[row['start']:row['end']] += 1
+        
+        # Plot coverage histogram
+        plt.figure(figsize=(12, 6))
+        plt.plot(coverage, color='b')
+        plt.title(f'Coverage Histogram for {chrom}')
+        plt.xlabel('Position')
+        plt.ylabel('Coverage')
+        plt.grid(True)
+        save_name = os.path.join(plotting_directory, f'{bed_basename}_{chrom}_coverage_histogram.png')
+        plt.savefig(save_name)
+        plt.close()

smftools/informatics/helpers/separate_bam_by_bc.py

@@ -1,7 +1,7 @@
 ## separate_bam_by_bc
 
 # General
-def separate_bam_by_bc(input_bam, output_prefix, bam_suffix):
+def separate_bam_by_bc(input_bam, output_prefix, bam_suffix, split_dir):
     """
     Separates an input BAM file on the BC SAM tag values.
 
@@ -9,6 +9,7 @@ def separate_bam_by_bc(input_bam, output_prefix, bam_suffix):
         input_bam (str): File path to the BAM file to split.
         output_prefix (str): A prefix to append to the output BAM.
         bam_suffix (str): A suffix to add to the bam file.
+        split_dir (str): String indicating path to directory to split BAMs into
     
     Returns:
         None
@@ -31,7 +32,8 @@ def separate_bam_by_bc(input_bam, output_prefix, bam_suffix):
                 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}_{bam_base_minus_suffix}_{bc_tag}{bam_suffix}", "wb", header=bam.header)
+                    output_path = os.path.join(split_dir, f"{output_prefix}_{bam_base_minus_suffix}_{bc_tag}{bam_suffix}")
+                    output_files[bc_tag] = pysam.AlignmentFile(output_path, "wb", header=bam.header)
                 # Write the read to the corresponding output BAM file
                 output_files[bc_tag].write(read)
             except KeyError:

smftools/informatics/helpers/split_and_index_BAM.py

@@ -1,12 +1,14 @@
 ## split_and_index_BAM
 
-def split_and_index_BAM(aligned_sorted_BAM, split_dir, bam_suffix):
+def split_and_index_BAM(aligned_sorted_BAM, split_dir, bam_suffix, output_directory, fasta):
     """
     A wrapper function for splitting BAMS and indexing them.
     Parameters:
         aligned_sorted_BAM (str): A string representing the file path of the aligned_sorted BAM file.
         split_dir (str): A string representing the file path to the directory to split the BAMs into.
         bam_suffix (str): A suffix to add to the bam file.
+        output_directory (str): A file path to the directory to output all the analyses.
+        fasta (str): File path to the reference genome to align to.
     
     Returns:
         None
@@ -17,13 +19,23 @@ def split_and_index_BAM(aligned_sorted_BAM, split_dir, bam_suffix):
     import subprocess
     import glob
     from .separate_bam_by_bc import separate_bam_by_bc
+    from .aligned_BAM_to_bed import aligned_BAM_to_bed
+    from .extract_readnames_from_BAM import extract_readnames_from_BAM
+    from .make_dirs import make_dirs
 
-    os.chdir(split_dir)
+    plotting_dir = os.path.join(output_directory, 'demultiplexed_bed_histograms')
+    bed_dir = os.path.join(output_directory, 'demultiplexed_read_alignment_coordinates')
+    make_dirs([plotting_dir, bed_dir])
     aligned_sorted_output = aligned_sorted_BAM + bam_suffix
     file_prefix = readwrite.date_string()
-    separate_bam_by_bc(aligned_sorted_output, file_prefix, bam_suffix)
+    separate_bam_by_bc(aligned_sorted_output, file_prefix, bam_suffix, split_dir)
     # Make a BAM index file for the BAMs in that directory
     bam_pattern = '*' + bam_suffix
     bam_files = glob.glob(os.path.join(split_dir, bam_pattern))
+    bam_files = [bam for bam in bam_files if '.bai' not in bam]
     for input_file in bam_files:
-        subprocess.run(["samtools", "index", input_file])
+        subprocess.run(["samtools", "index", input_file])
+        # Make a bed file of coordinates for the BAM
+        aligned_BAM_to_bed(input_file, plotting_dir, bed_dir, fasta)
+        # Make a text file of reads for the BAM
+        extract_readnames_from_BAM(input_file)

smftools/informatics/load_adata.py

@@ -0,0 +1,127 @@
+## load_adata
+
+def load_adata(config_path):
+    """
+    High-level function to call for converting raw sequencing data to an adata object. 
+    Works for nanopore pod5, fast5, and unaligned modBAM data types for direct SMF workflows.
+    Works for nanopore pod5, fast5, unaligned BAM for conversion SMF workflows.
+    Also works for illumina fastq and unaligned BAM for conversion SMF workflows.
+
+    Parameters:
+        config_path (str): A string representing the file path to the experiment configuration csv file.
+
+    Returns:
+        None
+    """
+    # Lazy importing of packages
+    from .helpers import LoadExperimentConfig, make_dirs, concatenate_fastqs_to_bam
+    from .fast5_to_pod5 import fast5_to_pod5
+    from .subsample_fasta_from_bed import subsample_fasta_from_bed
+    import os
+    import numpy as np
+    from pathlib import Path
+
+    # Default params
+    bam_suffix = '.bam' # If different, change from here.
+    split_dir = 'demultiplexed_BAMs' # If different, change from here.
+    strands = ['bottom', 'top'] # If different, change from here. Having both listed generally doesn't slow things down too much.
+    conversions = ['unconverted'] # The name to use for the unconverted files. 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
+    smf_modality = var_dict.get('smf_modality', default_value) # needed for specifying if the data is conversion SMF or direct methylation detection SMF. Necessary.
+    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.
+    fasta = var_dict.get('fasta', default_value) # Path to reference FASTA.
+    fasta_regions_of_interest = var_dict.get("fasta_regions_of_interest", default_value) # Path to a bed file listing coordinate regions of interest within the FASTA to include. Optional.
+    mapping_threshold = var_dict.get('mapping_threshold', default_value) # Minimum proportion of mapped reads that need to fall within a region to include in the final AnnData.
+    experiment_name = var_dict.get('experiment_name', default_value) # A key term to add to the AnnData file name.
+    model = var_dict.get('model', default_value) # needed for dorado basecaller
+    barcode_kit = var_dict.get('barcode_kit', default_value) # needed for dorado basecaller
+    # Conversion specific variable init
+    conversion_types = var_dict.get('conversion_types', default_value)
+    # Direct methylation 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)
+    batch_size = var_dict.get('batch_size', default_value)
+
+    # Make initial output directory
+    make_dirs([output_directory])
+    os.chdir(output_directory)
+    # Define the pathname to split BAMs into later during demultiplexing.
+    split_path = os.path.join(output_directory, split_dir)
+
+    # If fasta_regions_of_interest is passed, subsample the input FASTA on regions of interest and use the subsampled FASTA.
+    if fasta_regions_of_interest and '.bed' in fasta_regions_of_interest:
+        fasta_basename = os.path.basename(fasta).split('.fa')[0]
+        bed_basename_minus_suffix = os.path.basename(fasta_regions_of_interest).split('.bed')[0]
+        output_FASTA = fasta_basename + '_subsampled_by_' + bed_basename_minus_suffix + '.fasta'
+        subsample_fasta_from_bed(fasta, fasta_regions_of_interest, output_directory, output_FASTA)
+        fasta = os.path.join(output_directory, output_FASTA)
+
+    # If conversion_types is passed:
+    if conversion_types:
+        conversions += conversion_types
+
+    # 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']
+        input_is_fastq = input_data_filetype in ['.fastq', '.fq']
+        input_is_bam = input_data_filetype == bam_suffix
+        if input_is_fastq:
+            fastq_paths = [input_data_path]
+    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])
+        input_is_fastq = sum([True for file in input_files if '.fastq' in file or '.fq' in file])
+        input_is_bam = sum([True for file in input_files if bam_suffix in file])
+        if input_is_fastq:
+            fastq_paths = [os.path.join(input_data_path, file) for file in input_files if '.fastq' in file or '.fq' 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
+        input_is_pod5 = True
+        input_is_fast5 = False
+    
+    elif input_is_fastq:
+        output_bam = os.path.join(output_directory, 'FASTQs_concatenated_into_BAM.bam')
+        concatenate_fastqs_to_bam(fastq_paths, output_bam, barcode_tag='BC', gzip_suffix='.gz')
+        input_data_path = output_bam
+        input_is_bam = True
+        input_is_fastq = False
+
+    if input_is_pod5:
+        basecall = True
+    elif input_is_bam:
+        basecall = False
+    else:
+        print('Error, can not find input bam or pod5')
+
+    if smf_modality == 'conversion':
+        from .conversion_smf import conversion_smf
+        conversion_smf(fasta, output_directory, conversions, strands, model, input_data_path, split_path, barcode_kit, mapping_threshold, experiment_name, bam_suffix, basecall)
+    elif smf_modality == 'direct':
+        from .direct_smf import direct_smf
+        direct_smf(fasta, output_directory, mod_list, model, thresholds, input_data_path, split_path, barcode_kit, mapping_threshold, experiment_name, bam_suffix, batch_size, basecall)
+    else:
+            print("Error")

smftools/informatics/subsample_fasta_from_bed.py

@@ -0,0 +1,47 @@
+# subsample_fasta_from_bed
+
+def subsample_fasta_from_bed(input_FASTA, input_bed, output_directory, output_FASTA):
+    """
+    Take a genome-wide FASTA file and a bed file containing coordinate windows of interest. Outputs a subsampled FASTA.
+
+    Parameters:
+        input_FASTA (str): String representing the path to the input FASTA file.
+        input_bed (str): String representing the path to the input BED file.
+        output_directory (str): String representing the path to the output directory for the new FASTA file.
+        output_FASTA (str): Name of the output FASTA.
+    
+    Returns:
+        None
+    """
+    from pyfaidx import Fasta
+    import os
+
+    # Load the FASTA file using pyfaidx
+    fasta = Fasta(input_FASTA)
+
+    output_FASTA_path = os.path.join(output_directory, output_FASTA)
+    
+    # Open the BED file
+    with open(input_bed, 'r') as bed, open(output_FASTA_path, 'w') as out_fasta:
+        for line in bed:
+            # Each line in BED file contains: chrom, start, end (and possibly more columns)
+            fields = line.strip().split()
+            n_fields = len(fields)
+            chrom = fields[0]
+            start = int(fields[1])  # BED is 0-based
+            end = int(fields[2])    # BED is 0-based and end is exclusive
+            if n_fields > 3:
+                description = " ".join(fields[3:])
+            
+            # Check if the chromosome exists in the FASTA file
+            if chrom in fasta:
+                # pyfaidx is 1-based, so convert coordinates accordingly
+                sequence = fasta[chrom][start:end].seq
+                # Write the sequence to the output FASTA file
+                if n_fields > 3:
+                    out_fasta.write(f">{chrom}:{start}-{end}    {description}\n")
+                else:
+                    out_fasta.write(f">{chrom}:{start}-{end}\n")
+                out_fasta.write(f"{sequence}\n")
+            else:
+                print(f"Warning: {chrom} not found in the FASTA file")

smftools/informatics/subsample_pod5.py

@@ -6,7 +6,7 @@ def subsample_pod5(pod5_path, read_name_path, output_directory):
     This is a useful function when you have a list of read names that mapped to a region of interest that you want to reanalyze from the pod5 level.
 
     Parameters:
-        pod5_path (str): File path to the POD5 to subsample.
+        pod5_path (str): File path to the POD5 file (or directory of multiple pod5 files) to subsample.
         read_name_path (str | int): File path to a text file of read names. One read name per line. If an int value is passed, a random subset of that many reads will occur
         output_directory (str): A file path to the directory to output the file.
 
@@ -16,30 +16,86 @@ def subsample_pod5(pod5_path, read_name_path, output_directory):
     import pod5 as p5
     import os
 
-    input_pod5_base = os.path.basename(pod5_path)
+    if os.path.isdir(pod5_path):
+        pod5_path_is_dir = True
+        input_pod5_base = 'input_pod5s.pod5'
+        files = os.listdir(pod5_path)
+        pod5_files = [os.path.join(pod5_path, file) for file in files if '.pod5' in file]
+        pod5_files.sort()
+        print(f'Found input pod5s: {pod5_files}')
+    
+    elif os.path.exists(pod5_path):
+        pod5_path_is_dir = False
+        input_pod5_base = os.path.basename(pod5_path)
+
+    else:
+        print('Error: pod5_path passed does not exist')
+        return None
 
     if type(read_name_path) == str:
         input_read_name_base = os.path.basename(read_name_path)
         output_base = input_pod5_base.split('.pod5')[0] + '_' + input_read_name_base.split('.txt')[0] + '_subsampled.pod5'
+
         # extract read names into a list of strings
         with open(read_name_path, 'r') as file:
             read_names = [line.strip() for line in file]
-        with p5.Reader(pod5_path) as reader:
-            read_records = []
-            for read_record in reader.reads(selection=read_names):
-                read_records.append(read_record.to_read())
+
+        print(f'Looking for read_ids: {read_names}')
+        read_records = []
+
+        if pod5_path_is_dir:
+            for input_pod5 in pod5_files:
+                with p5.Reader(input_pod5) as reader:
+                    try:
+                        for read_record in reader.reads(selection=read_names, missing_ok=True):
+                            read_records.append(read_record.to_read())      
+                            print(f'Found read in {input_pod5}: {read_record.read_id}')      
+                    except:
+                        print('Skipping pod5, could not find reads')    
+        else:    
+            with p5.Reader(pod5_path) as reader:
+                try:
+                    for read_record in reader.reads(selection=read_names):
+                        read_records.append(read_record.to_read())
+                        print(f'Found read in {input_pod5}: {read_record}')  
+                except:
+                    print('Could not find reads')   
 
     elif type(read_name_path) == int:
         import random
         output_base = input_pod5_base.split('.pod5')[0] + f'_{read_name_path}_randomly_subsampled.pod5'
-        with p5.Reader(pod5_path) as reader:
-            all_read_records = []
-            for read_record in reader.reads():
-                all_read_records.append(read_record.to_read())
-        if read_name_path <= len(all_read_records):
-            read_records = random.sample(all_read_records, read_name_path)
+        all_read_records = []
+
+        if pod5_path_is_dir:
+            # Shuffle the list of input pod5 paths
+            random.shuffle(pod5_files)
+            for input_pod5 in pod5_files:
+                # iterate over the input pod5s
+                print(f'Opening pod5 file {input_pod5}')
+                with p5.Reader(pod5_path) as reader:
+                    for read_record in reader.reads():
+                        all_read_records.append(read_record.to_read())
+                # When enough reads are in all_read_records, stop accumulating reads.
+                if len(all_read_records) >= read_name_path:
+                    break
+
+            if read_name_path <= len(all_read_records):
+                read_records = random.sample(all_read_records, read_name_path)
+            else:
+                print('Trying to sample more reads than are contained in the input pod5s, taking all reads')
+                read_records = all_read_records
+                    
         else:
-            print('Trying to sample more reads than are contained in the input pod5, please try a lower value.')
+            with p5.Reader(pod5_path) as reader:
+                for read_record in reader.reads():
+                    # get all read records from the input pod5
+                    all_read_records.append(read_record.to_read())
+            if read_name_path <= len(all_read_records):
+                # if the subsampling amount is less than the record amount in the file, randomly subsample the reads
+                read_records = random.sample(all_read_records, read_name_path)
+            else:
+                print('Trying to sample more reads than are contained in the input pod5s, taking all reads')
+                read_records = all_read_records
 
     output_pod5 = os.path.join(output_directory, output_base)
 

smftools/preprocessing/__init__.py

@@ -9,8 +9,10 @@ from .clean_NaN import clean_NaN
 from .filter_converted_reads_on_methylation import filter_converted_reads_on_methylation
 from .filter_reads_on_length import filter_reads_on_length
 from .invert_adata import invert_adata
+from .load_sample_sheet import load_sample_sheet
 from .mark_duplicates import mark_duplicates
 from .remove_duplicates import remove_duplicates
+from .recipes import recipe_1_Kissiov_and_McKenna_2025, recipe_2_Kissiov_and_McKenna_2025
 
 __all__ = [
     "append_C_context",
@@ -24,6 +26,9 @@ __all__ = [
     "filter_converted_reads_on_methylation",
     "filter_reads_on_length",
     "invert_adata",
+    "load_sample_sheet",
     "mark_duplicates",
-    "remove_duplicates"
+    "remove_duplicates",
+    "recipe_1_Kissiov_and_McKenna_2025",
+    "recipe_2_Kissiov_and_McKenna_2025"
 ]

smftools/preprocessing/append_C_context.py

@@ -17,29 +17,52 @@ def append_C_context(adata, obs_column='Reference', use_consensus=False):
     """
     import numpy as np
     import anndata as ad
-    site_types = ['GpC_site', 'CpG_site', 'ambiguous_GpC_site', 'ambiguous_CpG_site', 'other_C']
+    site_types = ['GpC_site', 'CpG_site', 'ambiguous_GpC_CpG_site', 'other_C']
     categories = adata.obs[obs_column].cat.categories
     for cat in categories:
+        # Assess if the strand is the top or bottom strand converted
+        if 'top' in cat:
+            strand = 'top'
+        elif 'bottom' in cat:
+            strand = 'bottom'
+
         if use_consensus:
             sequence = adata.uns[f'{cat}_consensus_sequence']
         else:
+            # This sequence is the unconverted FASTA sequence of the original input FASTA for the locus
             sequence = adata.uns[f'{cat}_FASTA_sequence']
+        # Init a dict keyed by reference site type that points to a bool of whether the position is that site type.    
         boolean_dict = {}
         for site_type in site_types:
             boolean_dict[f'{cat}_{site_type}'] = np.full(len(sequence), False, dtype=bool)
-        # Iterate through the sequence and apply the criteria
-        for i in range(1, len(sequence) - 1):
-            if sequence[i] == 'C':
-                if sequence[i - 1] == 'G' and sequence[i + 1] != 'G':
-                    boolean_dict[f'{cat}_GpC_site'][i] = True
-                elif sequence[i - 1] == 'G' and sequence[i + 1] == 'G':
-                    boolean_dict[f'{cat}_ambiguous_GpC_site'][i] = True
-                elif sequence[i - 1] != 'G' and sequence[i + 1] == 'G':
-                    boolean_dict[f'{cat}_CpG_site'][i] = True
-                elif sequence[i - 1] == 'G' and sequence[i + 1] == 'G':
-                    boolean_dict[f'{cat}_ambiguous_CpG_site'][i] = True
-                elif sequence[i - 1] != 'G' and sequence[i + 1] != 'G':
-                    boolean_dict[f'{cat}_other_C'][i] = True
+        
+        if strand == 'top':
+            # Iterate through the sequence and apply the criteria
+            for i in range(1, len(sequence) - 1):
+                if sequence[i] == 'C':
+                    if sequence[i - 1] == 'G' and sequence[i + 1] != 'G':
+                        boolean_dict[f'{cat}_GpC_site'][i] = True
+                    elif sequence[i - 1] == 'G' and sequence[i + 1] == 'G':
+                        boolean_dict[f'{cat}_ambiguous_GpC_CpG_site'][i] = True
+                    elif sequence[i - 1] != 'G' and sequence[i + 1] == 'G':
+                        boolean_dict[f'{cat}_CpG_site'][i] = True
+                    elif sequence[i - 1] != 'G' and sequence[i + 1] != 'G':
+                        boolean_dict[f'{cat}_other_C'][i] = True
+        elif strand == 'bottom':
+            # Iterate through the sequence and apply the criteria
+            for i in range(1, len(sequence) - 1):
+                if sequence[i] == 'G':
+                    if sequence[i + 1] == 'C' and sequence[i - 1] != 'C':
+                        boolean_dict[f'{cat}_GpC_site'][i] = True
+                    elif sequence[i - 1] == 'C' and sequence[i + 1] == 'C':
+                        boolean_dict[f'{cat}_ambiguous_GpC_CpG_site'][i] = True
+                    elif sequence[i - 1] == 'C' and sequence[i + 1] != 'C':
+                        boolean_dict[f'{cat}_CpG_site'][i] = True
+                    elif sequence[i - 1] != 'C' and sequence[i + 1] != 'C':
+                        boolean_dict[f'{cat}_other_C'][i] = True
+        else:
+            print('Error: top or bottom strand of conversion could not be determined. Ensure this value is in the Reference name.')
+
         for site_type in site_types:
             adata.var[f'{cat}_{site_type}'] = boolean_dict[f'{cat}_{site_type}'].astype(bool)
             adata.obsm[f'{cat}_{site_type}'] = adata[:, adata.var[f'{cat}_{site_type}'] == True].copy().X

smftools/preprocessing/calculate_complexity.py

@@ -1,16 +1,16 @@
 ## calculate_complexity
 
-def calculate_complexity(adata, obs_column='Reference', sample_col='Sample_names', plot=True, save_plot=False, output_directory=''):
+def calculate_complexity(adata, output_directory='', obs_column='Reference', sample_col='Sample_names', plot=True, save_plot=False):
     """
     A complexity analysis of the library.
 
     Parameters:
         adata (AnnData): An adata object with mark_duplicates already run.
+        output_directory (str): String representing the path to the output directory.
         obs_column (str): String of the obs column to iterate over.
         sample_col (str): String of the sample column to iterate over.
         plot (bool): Whether to plot the complexity model.
         save_plot (bool): Whether to save the complexity model.
-        output_directory (str): String representing the path to the output directory.
 
     Returns:
         None

smftools/preprocessing/calculate_consensus.py

@@ -0,0 +1,47 @@
+# calculate_consensus
+
+def calculate_consensus(adata, reference, sample=False, reference_column='Reference', sample_column='Sample'):
+    """
+    Takes an input AnnData object, the reference to subset on, and the sample name to subset on to calculate the consensus sequence of the read set.
+
+    Parameters:
+        adata (AnnData): The input adata to append consensus metadata to.
+        reference (str): The name of the reference to subset the adata on.
+        sample (bool | str): If False, uses all samples. If a string is passed, the adata is further subsetted to only analyze that sample.
+        reference_column (str): The name of the reference column (Default is 'Reference')
+        sample_column (str): The name of the sample column (Default is 'Sample)
+
+    Returns:
+        None
+    
+    """
+    import numpy as np
+
+    # Subset the adata on the refernce of interest. Optionally, subset additionally on a sample of interest.
+    record_subset = adata[adata.obs[reference_column] == reference].copy()
+    if sample:
+        record_subset = record_subset[record_subset.obs[sample_column] == sample].copy()
+    else:
+        pass
+
+    # Grab layer names from the adata object that correspond to the binary encodings of the read sequences.
+    layers = [layer for layer in record_subset.layers if '_binary_' in layer]
+    layer_map, layer_counts = {}, []
+    for i, layer in enumerate(layers):
+        # Gives an integer mapping to access which sequence base the binary layer is encoding
+        layer_map[i] = layer.split('_')[0]
+        # Get the positional counts from all reads for the given base identity.
+        layer_counts.append(np.sum(record_subset.layers[layer], axis=0))
+    # Combine the positional counts array derived from each binary base layer into an ndarray
+    count_array = np.array(layer_counts)
+    # Determine the row index that contains the largest count for each position and store this in an array.
+    nucleotide_indexes = np.argmax(count_array, axis=0)
+    # Map the base sequence derived from the row index array to attain the consensus sequence in a list.
+    consensus_sequence_list = [layer_map[i] for i in nucleotide_indexes]
+
+    if sample:
+        adata.var[f'{reference}_consensus_from_{sample}'] = consensus_sequence_list
+    else:
+        adata.var[f'{reference}_consensus_across_samples'] = consensus_sequence_list
+
+    adata.uns[f'{reference}_consensus_sequence'] = consensus_sequence_list