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

smftools/informatics/helpers/separate_bam_by_bc.py

@@ -1,43 +0,0 @@
-## separate_bam_by_bc
-
-# General
-def separate_bam_by_bc(input_bam, output_prefix, bam_suffix, split_dir):
-    """
-    Separates an input BAM file on the BC SAM tag values.
-
-    Parameters:
-        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
-            Writes out split BAM files.
-    """
-    import pysam
-    import os
-
-    bam_base = os.path.basename(input_bam)
-    bam_base_minus_suffix = bam_base.split(bam_suffix)[0]
-
-    # 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_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:
-                 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()

smftools/informatics/helpers/split_and_index_BAM.py

@@ -1,41 +0,0 @@
-## split_and_index_BAM
-
-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
-            Splits an input BAM file on barcode value and makes a BAM index file.
-    """
-    from .. import readwrite
-    import os
-    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
-
-    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, 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])
-        # 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

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

@@ -1,106 +0,0 @@
-## readwrite ##
-
-######################################################################################################
-## Datetime functionality
-def date_string():
-    """
-    Each time this is called, it returns the current date string
-    """
-    from datetime import datetime
-    current_date = datetime.now()
-    date_string = current_date.strftime("%Y%m%d")
-    date_string = date_string[2:]
-    return date_string
-
-def time_string():
-    """
-    Each time this is called, it returns the current time string
-    """
-    from datetime import datetime
-    current_time = datetime.now()
-    return current_time.strftime("%H:%M:%S")
-######################################################################################################
-
-######################################################################################################
-## Numpy, Pandas, Anndata functionality
-def adata_to_df(adata, layer=None):
-    """
-    Input: An adata object with a specified layer.
-    Output: A dataframe for the specific layer.
-    """
-    import pandas as pd
-    import anndata as ad
-
-    # Extract the data matrix from the given layer
-    if layer:
-        data_matrix = adata.layers[layer]
-    else:
-        data_matrix = adata.X
-    # Extract observation (read) annotations
-    obs_df = adata.obs
-    # Extract variable (position) annotations
-    var_df = adata.var
-    # Convert data matrix and annotations to pandas DataFrames
-    df = pd.DataFrame(data_matrix, index=obs_df.index, columns=var_df.index)
-    return df
-
-def save_matrix(matrix, save_name):
-    """
-    Input: A numpy matrix and a save_name
-    Output: A txt file representation of the data matrix
-    """
-    import numpy as np
-    np.savetxt(f'{save_name}.txt', matrix)
-
-def concatenate_h5ads(output_file, file_suffix='h5ad.gz', delete_inputs=True):
-    """
-    Concatenate all h5ad files in a directory and delete them after the final adata is written out.
-    Input: an output file path relative to the directory in which the function is called
-    """
-    import os
-    import anndata as ad
-    # Runtime warnings
-    import warnings
-    warnings.filterwarnings('ignore', category=UserWarning, module='anndata')
-    warnings.filterwarnings('ignore', category=FutureWarning, module='anndata')
-    
-    # List all files in the directory
-    files = os.listdir(os.getcwd())
-    # get current working directory
-    cwd = os.getcwd()
-    suffix = file_suffix
-    # Filter file names that contain the search string in their filename and keep them in a list
-    hdfs = [hdf for hdf in files if suffix in hdf]
-    # Sort file list by names and print the list of file names
-    hdfs.sort()
-    print('{0} sample files found: {1}'.format(len(hdfs), hdfs))
-    # Iterate over all of the hdf5 files and concatenate them.
-    final_adata = None
-    for hdf in hdfs:
-        print('{0}: Reading in {1} hdf5 file'.format(time_string(), hdf))
-        temp_adata = ad.read_h5ad(hdf)
-        if final_adata:
-            print('{0}: Concatenating final adata object with {1} hdf5 file'.format(time_string(), hdf))
-            final_adata = ad.concat([final_adata, temp_adata], join='outer', index_unique=None)
-        else:
-            print('{0}: Initializing final adata object with {1} hdf5 file'.format(time_string(), hdf))
-            final_adata = temp_adata
-    print('{0}: Writing final concatenated hdf5 file'.format(time_string()))
-    final_adata.write_h5ad(output_file, compression='gzip')
-
-    # Delete the individual h5ad files and only keep the final concatenated file
-    if delete_inputs:
-        files = os.listdir(os.getcwd())
-        hdfs = [hdf for hdf in files if suffix in hdf]
-        if output_file in hdfs:
-            hdfs.remove(output_file)
-            # Iterate over the files and delete them
-            for hdf in hdfs:
-                try:
-                    os.remove(hdf)
-                    print(f"Deleted file: {hdf}")
-                except OSError as e:
-                    print(f"Error deleting file {hdf}: {e}")
-    else:
-        print('Keeping input files')
-######################################################################################################

smftools/informatics/subsample_fasta_from_bed.py

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

@@ -1,104 +0,0 @@
-# subsample_pod5
-
-def subsample_pod5(pod5_path, read_name_path, output_directory):
-    """
-    Takes a POD5 file and a text file containing read names of interest and writes out a subsampled POD5 for just those reads.
-    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 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.
-
-    Returns:
-        None
-    """
-    import pod5 as p5
-    import os
-
-    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]
-
-        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'
-        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:
-            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)
-
-    # Write the subsampled POD5
-    with p5.Writer(output_pod5) as writer:
-        writer.add_reads(read_records)

smftools/preprocessing/__init__.py

@@ -1,34 +0,0 @@
-from .append_C_context import append_C_context
-from .binarize_on_Youden import binarize_on_Youden
-from .calculate_complexity import calculate_complexity
-from .calculate_converted_read_methylation_stats import calculate_converted_read_methylation_stats
-from .calculate_coverage import calculate_coverage
-from .calculate_position_Youden import calculate_position_Youden
-from .calculate_read_length_stats import calculate_read_length_stats
-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",
-    "binarize_on_Youden",
-    "calculate_complexity",
-    "calculate_converted_read_methylation_stats",
-    "calculate_coverage",    
-    "calculate_position_Youden",
-    "calculate_read_length_stats",
-    "clean_NaN",   
-    "filter_converted_reads_on_methylation",
-    "filter_reads_on_length",
-    "invert_adata",
-    "load_sample_sheet",
-    "mark_duplicates",
-    "remove_duplicates",
-    "recipe_1_Kissiov_and_McKenna_2025",
-    "recipe_2_Kissiov_and_McKenna_2025"
-]

smftools/preprocessing/append_C_context.py

@@ -1,69 +0,0 @@
-## append_C_context
-
-## Conversion SMF Specific 
-# Read methylation QC
-def append_C_context(adata, obs_column='Reference', use_consensus=False):
-    """
-    Adds Cytosine context to the position within the given category. When use_consensus is True, it uses the consensus sequence, otherwise it defaults to the FASTA sequence.
-
-    Parameters:
-        adata (AnnData): The input adata object.
-        obs_column (str): The observation column in which to stratify on. Default is 'Reference', which should not be changed for most purposes.
-        use_consensus (bool): A truth statement indicating whether to use the consensus sequence from the reads mapped to the reference. If False, the reference FASTA is used instead.
-    Input: An adata object, the obs_column of interst, and whether to use the consensus sequence from the category.
-    
-    Returns:
-        None
-    """
-    import numpy as np
-    import anndata as ad
-    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)
-        
-        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
-