smftools 0.1.0__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

@@ -1,14 +1,21 @@
 # one_hot_encode
-from .. import readwrite
 
 # String encodings
 def one_hot_encode(sequence):
     """
-    Input: A sequence string of a read.
-    Output: One hot encoding of the sequence string.
+    One hot encodes a sequence list.
+    Parameters:
+        sequence (list): A list of DNA base sequences.
+
+    Returns:
+        flattened (ndarray): A numpy ndarray holding a flattened one hot encoding of the input 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
+    import numpy as np
+
+    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,12 +1,26 @@
 ## separate_bam_by_bc
-import pysam
 
 # General
-def separate_bam_by_bc(input_bam, output_prefix):
+def separate_bam_by_bc(input_bam, output_prefix, bam_suffix, split_dir):
     """
-    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.
+    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
@@ -18,7 +32,8 @@ def separate_bam_by_bc(input_bam, output_prefix):
                 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)
+                    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,21 +1,41 @@
 ## split_and_index_BAM
-from .. import readwrite
-import os
-import subprocess
-import glob
-from .separate_bam_by_bc import separate_bam_by_bc
 
-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
+    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.
     """
-    os.chdir(split_dir)
+    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.datestring()
-    separate_bam_by_bc(aligned_sorted_output, file_prefix)
+    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])
-        print(f"Indexed {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/readwrite.py

@@ -1,27 +1,12 @@
 ## readwrite ##
 
-# Basic I/O
-import os
-# Datetime
-from datetime import datetime
-# Data structures and basic operations
-import math
-import numpy as np
-import pandas as pd
-import anndata as ad
-import scipy.sparse as sp
-
-# Runtime warnings
-import warnings
-warnings.filterwarnings('ignore', category=UserWarning, module='anndata')
-warnings.filterwarnings('ignore', category=FutureWarning, module='anndata')
-
 ######################################################################################################
 ## 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:]
@@ -31,6 +16,7 @@ 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")
 ######################################################################################################
@@ -42,6 +28,9 @@ 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]
@@ -60,6 +49,7 @@ 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):
@@ -67,6 +57,13 @@ 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

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

@@ -0,0 +1,104 @@
+# 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,35 +1,34 @@
 from .append_C_context import append_C_context
 from .binarize_on_Youden import binarize_on_Youden
-from .binary_layers_to_ohe import binary_layers_to_ohe
 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_pairwise_hamming_distances import calculate_pairwise_hamming_distances
 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 .min_non_diagonal import min_non_diagonal
 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",
-    "binary_layers_to_ohe",
     "calculate_complexity",
     "calculate_converted_read_methylation_stats",
     "calculate_coverage",    
-    "calculate_pairwise_hamming_distances",
     "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",
-    "min_non_diagonal",
-    "remove_duplicates"
+    "remove_duplicates",
+    "recipe_1_Kissiov_and_McKenna_2025",
+    "recipe_2_Kissiov_and_McKenna_2025"
 ]