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

smftools/__init__.py

@@ -0,0 +1,29 @@
+"""smftools"""
+
+import logging
+import warnings
+
+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 .readwrite import adata_to_df, safe_write_h5ad, merge_barcoded_anndatas
+
+
+from importlib.metadata import version
+
+package_name = "smftools"
+__version__ = version(package_name)
+
+__all__ = [
+    "adata_to_df",
+    "inform",
+    "pp",
+    "tl",
+    "pl",
+    "readwrite",
+    "datasets",
+    "safe_write_h5ad",
+    "merge_barcoded_anndatas"
+]

smftools/_settings.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+from typing import Union
+
+class SMFConfig:
+    """\
+    Config for smftools.
+    """
+
+    def __init__(
+        self,
+        *,
+        datasetdir: Union[Path, str] = "./datasets/"
+    ):
+        self._datasetdir = Path(datasetdir) if isinstance(datasetdir, str) else datasetdir
+
+    @property
+    def datasetdir(self) -> Path:
+        return self._datasetdir
+
+settings = SMFConfig()

smftools/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.7"

smftools/datasets/F1_sample_sheet.csv

@@ -0,0 +1,5 @@
+Sample,Sample_names,MTase,Time (min),Notes
+barcode0001_sorted,Neither,M.CviPI,7.5,Cultured in IL2
+barcode0002_sorted,BALBC,M.CviPI,7.5,Cultured in IL2
+barcode0003_sorted,B6,M.CviPI,7.5,Cultured in IL2
+barcode0004_sorted,Both,M.CviPI,7.5,Cultured in IL2

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,28 @@
+## datasets
+
+def import_HERE():
+    """
+    Imports HERE for loading datasets
+    """
+    from pathlib import Path
+    from .._settings import settings
+    HERE = Path(__file__).parent
+    return HERE
+
+def dCas9_kinetics():
+    """
+    in vitro Hia5 dCas9 kinetics SMF dataset. Nanopore HAC m6A modcalls.
+    """
+    import anndata as ad
+    HERE = import_HERE()
+    filepath = HERE / "dCas9_m6A_invitro_kinetics.h5ad.gz"
+    return ad.read_h5ad(filepath)
+
+def Kissiov_and_McKenna_2025():
+    """
+    F1 Hybrid M.CviPI natural killer cell SMF. Nanopore canonical calls of NEB EMseq converted SMF gDNA.
+    """
+    import anndata as ad
+    HERE = import_HERE()
+    filepath = HERE / "F1_hybrid_NKG2A_enhander_promoter_GpC_conversion_SMF.h5ad.gz"
+    return ad.read_h5ad(filepath)

smftools/informatics/__init__.py

@@ -0,0 +1,16 @@
+from . import helpers
+from .basecall_pod5s import basecall_pod5s
+from .load_adata import load_adata
+from .subsample_fasta_from_bed import subsample_fasta_from_bed
+from .subsample_pod5 import subsample_pod5
+from .fast5_to_pod5 import fast5_to_pod5
+
+
+__all__ = [
+    "basecall_pod5s",
+    "load_adata",
+    "subsample_fasta_from_bed",
+    "subsample_pod5",
+    "fast5_to_pod5",
+    "helpers"
+]

smftools/informatics/archived/bam_conversion.py

@@ -0,0 +1,59 @@
+## bam_conversion
+
+def bam_conversion(fasta, output_directory, conversion_types, strands, basecalled_path, split_dir, mapping_threshold, experiment_name, bam_suffix):
+    """
+    Converts a BAM file from a nanopore conversion SMF experiment to an adata object.
+
+    Parameters:
+        fasta (str): File path to the reference genome to align to.
+        output_directory (str): A file path to the directory to output all the analyses.
+        conversion_type (list): A list of strings of the conversion types to use in the analysis.
+        strands (list): A list of converstion strands to use in the experiment.
+        basecalled_path (str): a string representing the file path to the experiment BAM or FASTQ file.
+        split_dir (str): A string representing the file path to the directory to split the BAMs into.
+        mapping_threshold (float): A value in between 0 and 1 to threshold the minimal fraction of aligned reads which map to the reference region. References with values above the threshold are included in the output adata.
+        experiment_name (str): A string to provide an experiment name to the output adata file.
+        bam_suffix (str): A suffix to add to the bam file.
+
+    Returns:
+        None
+    """
+    from .helpers import align_and_sort_BAM, converted_BAM_to_adata, generate_converted_FASTA, split_and_index_BAM, make_dirs
+    import os
+    input_basecalled_basename = os.path.basename(basecalled_path)
+    bam_basename = input_basecalled_basename.split(".")[0]
+    output_bam=f"{output_directory}/{bam_basename}"
+    aligned_BAM=f"{output_bam}_aligned"
+    aligned_sorted_BAM=f"{aligned_BAM}_sorted"
+
+    os.chdir(output_directory)
+
+    # 1) Convert FASTA file
+    fasta_basename = os.path.basename(fasta)
+    converted_FASTA_basename = fasta_basename.split('.fa')[0]+'_converted.fasta'
+    converted_FASTA = os.path.join(output_directory, converted_FASTA_basename)
+    if 'converted.fa' in fasta:
+        print(fasta + ' is already converted. Using existing converted FASTA.')
+        converted_FASTA = fasta
+    elif os.path.exists(converted_FASTA):
+        print(converted_FASTA + ' already exists. Using existing converted FASTA.')
+    else:
+        generate_converted_FASTA(fasta, conversion_types, strands, converted_FASTA)
+
+    # 2) Align the basecalled file to the converted reference FASTA and sort the bam on positional coordinates. Also make an index and a bed file of mapped reads
+    aligned_output = aligned_BAM + bam_suffix
+    sorted_output = aligned_sorted_BAM + bam_suffix
+    if os.path.exists(aligned_output) and os.path.exists(sorted_output):
+        print(sorted_output + ' already exists. Using existing aligned/sorted BAM.')
+    else:
+        align_and_sort_BAM(converted_FASTA, basecalled_path, bam_suffix, output_directory)
+
+    ### 3) Split the aligned and sorted BAM files by barcode (BC Tag) into the split_BAM directory###
+    if os.path.isdir(split_dir):
+        print(split_dir + ' already exists. Using existing aligned/sorted/split BAMs.')
+    else:
+        make_dirs([split_dir])
+        split_and_index_BAM(aligned_sorted_BAM, split_dir, bam_suffix, output_directory)
+
+    # 4) Take the converted BAM and load it into an adata object. 
+    converted_BAM_to_adata(converted_FASTA, split_dir, mapping_threshold, experiment_name, conversion_types, bam_suffix)

smftools/informatics/archived/bam_direct.py

@@ -0,0 +1,63 @@
+## bam_direct
+
+def bam_direct(fasta, output_directory, mod_list, thresholds, bam_path, split_dir, mapping_threshold, experiment_name, bam_suffix, batch_size):
+    """
+    Converts a POD5 file from a nanopore native SMF experiment to an adata object.
+
+    Parameters:
+        fasta (str): File path to the reference genome to align to.
+        output_directory (str): A file path to the directory to output all the analyses.
+        mod_list (list): A list of strings of the modification types to use in the analysis.
+        thresholds (list): A list of floats to pass for call thresholds.
+        bam_path (str): a string representing the file path to the the BAM file.
+        split_dir (str): A string representing the file path to the directory to split the BAMs into.
+        mapping_threshold (float): A value in between 0 and 1 to threshold the minimal fraction of aligned reads which map to the reference region. References with values above the threshold are included in the output adata.
+        experiment_name (str): A string to provide an experiment name to the output adata file.
+        bam_suffix (str): A suffix to add to the bam file.
+        batch_size (int): An integer number of TSV files to analyze in memory at once while loading the final adata object.
+
+    Returns:
+        None   
+    """
+    from .helpers import align_and_sort_BAM, extract_mods, make_modbed, modkit_extract_to_adata, modQC, split_and_index_BAM, make_dirs
+    import os
+    input_bam_base = os.path.basename(bam_path)
+    bam_basename = input_bam_base.split(bam_suffix)[0]
+    output_bam=f"{output_directory}/{bam_basename}"
+    aligned_BAM=f"{output_bam}_aligned"
+    aligned_sorted_BAM=f"{aligned_BAM}_sorted"
+    mod_bed_dir=f"{output_directory}/split_mod_beds"
+    mod_tsv_dir=f"{output_directory}/split_mod_tsvs"
+
+    aligned_output = aligned_BAM + bam_suffix
+    aligned_sorted_output = aligned_sorted_BAM + bam_suffix
+    mod_map = {'6mA': '6mA', '5mC_5hmC': '5mC'}
+    mods = [mod_map[mod] for mod in mod_list]
+
+    os.chdir(output_directory)
+
+    # 1) Align the BAM to the reference FASTA. Also make an index and a bed file of mapped reads
+    if os.path.exists(aligned_output) and os.path.exists(aligned_sorted_output):
+        print(aligned_sorted_output + ' already exists. Using existing aligned/sorted BAM.')
+    else:
+        align_and_sort_BAM(fasta, bam_path, bam_suffix, output_directory)
+    # 2) Split the aligned and sorted BAM files by barcode (BC Tag) into the split_BAM directory
+    if os.path.isdir(split_dir):
+        print(split_dir + ' already exists. Using existing aligned/sorted/split BAMs.')
+    else:
+        make_dirs([split_dir])
+        split_and_index_BAM(aligned_sorted_BAM, split_dir, bam_suffix, output_directory)
+    # 3) Using nanopore modkit to work with modified BAM files ###
+    if os.path.isdir(mod_bed_dir):
+        print(mod_bed_dir + ' already exists')
+    else:
+        make_dirs([mod_bed_dir])  
+        modQC(aligned_sorted_output, thresholds) # get QC metrics for mod calls
+        make_modbed(aligned_sorted_output, thresholds, mod_bed_dir) # Generate bed files of position methylation summaries for every sample
+    if os.path.isdir(mod_tsv_dir):
+        print(mod_tsv_dir + ' already exists')
+    else:
+        make_dirs([mod_tsv_dir])  
+        extract_mods(thresholds, mod_tsv_dir, split_dir, bam_suffix) # Extract methylations calls for split BAM files into split TSV files
+    #4 Load the modification data from TSVs into an adata object
+    modkit_extract_to_adata(fasta, split_dir, mapping_threshold, experiment_name, mods, batch_size, mod_tsv_dir)

smftools/informatics/archived/basecalls_to_adata.py

@@ -0,0 +1,71 @@
+## basecalls_to_adata
+
+def basecalls_to_adata(config_path):
+    """
+    High-level function to call for loading basecalled SMF data from a BAM file into an adata object. Also works with FASTQ for conversion SMF.
+
+    Parameters:
+        config_path (str): A string representing the file path to the experiment configuration csv file.
+
+    Returns:
+        None
+    """
+    from .helpers import LoadExperimentConfig, make_dirs
+    from .subsample_fasta_from_bed import subsample_fasta_from_bed
+    import os
+    import numpy as np
+    bam_suffix = '.bam' # If different, change from here.
+    split_dir = 'split_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 the value np.nan if they are either empty in the experiment_config.csv or if the variable is fully omitted from the csv.
+    default_value = None
+    
+    conversion_types = var_dict.get('conversion_types', default_value)
+    output_directory = var_dict.get('output_directory', default_value)
+    smf_modality = var_dict.get('smf_modality', default_value)
+    fasta = var_dict.get('fasta', default_value)
+    fasta_regions_of_interest = var_dict.get("fasta_regions_of_interest", default_value)
+    basecalled_path = var_dict.get('basecalled_path', default_value)
+    mapping_threshold = var_dict.get('mapping_threshold', default_value)
+    experiment_name = var_dict.get('experiment_name', default_value)
+    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)
+    mod_list = var_dict.get('mod_list', default_value)
+    batch_size = var_dict.get('batch_size', default_value)
+    thresholds = [filter_threshold, m6A_threshold, m5C_threshold, hm5C_threshold]
+
+    split_path = os.path.join(output_directory, split_dir)
+
+    make_dirs([output_directory])
+    os.chdir(output_directory)
+
+    conversions += conversion_types
+
+    # If a bed file is passed, subsample the input FASTA on regions of interest and use the subsampled FASTA.
+    if fasta_regions_of_interest != None:
+        if '.bed' in fasta_regions_of_interest:
+            fasta_basename = os.path.basename(fasta)
+            bed_basename_minus_suffix = os.path.basename(fasta_regions_of_interest).split('.bed')[0]
+            output_FASTA = bed_basename_minus_suffix + '_' + fasta_basename
+            subsample_fasta_from_bed(fasta, fasta_regions_of_interest, output_directory, output_FASTA)
+            fasta = output_FASTA
+
+    if smf_modality == 'conversion':
+        from .bam_conversion import bam_conversion
+        bam_conversion(fasta, output_directory, conversions, strands, basecalled_path, split_path, mapping_threshold, experiment_name, bam_suffix)
+    elif smf_modality == 'direct':
+        if bam_suffix in basecalled_path:
+            from .bam_direct import bam_direct
+            bam_direct(fasta, output_directory, mod_list, thresholds, basecalled_path, split_path, mapping_threshold, experiment_name, bam_suffix, batch_size)
+        else:
+            print('basecalls_to_adata function only work with the direct modality when the input filetype is BAM and not FASTQ.')
+    else:
+        print("Error")

smftools/informatics/archived/print_bam_query_seq.py

@@ -0,0 +1,29 @@
+import pysam
+import sys
+
+def extract_reads(bam_file_path, num_reads=10):
+    # Open the BAM file
+    bam_file = pysam.AlignmentFile(bam_file_path, "rb")
+    
+    # Iterate through the first 'num_reads' reads and print the sequences
+    count = 0
+    for read in bam_file:
+        print(f"Read {count + 1}: {read.query_sequence}")
+        count += 1
+        if count >= num_reads:
+            break
+    
+    # Close the BAM file
+    bam_file.close()
+
+if __name__ == "__main__":
+    # Ensure a BAM file path is provided as a command line argument
+    if len(sys.argv) < 2:
+        print("Usage: python extract_reads.py <path_to_bam_file>")
+        sys.exit(1)
+
+    # Get the BAM file path from command line arguments
+    bam_file_path = sys.argv[1]
+    
+    # Call the function to extract the first 10 reads
+    extract_reads(bam_file_path)

smftools/informatics/basecall_pod5s.py

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

smftools/informatics/conversion_smf.py

@@ -0,0 +1,132 @@
+## conversion_smf
+
+def conversion_smf(fasta, output_directory, conversion_types, strands, model_dir, model, input_data_path, split_dir, barcode_kit, mapping_threshold, experiment_name, bam_suffix, basecall, barcode_both_ends, trim, device, make_bigwigs, threads, input_already_demuxed):
+    """
+    Processes sequencing data from a conversion SMF experiment to an adata object.
+
+    Parameters:
+        fasta (str): File path to the reference genome to align to.
+        output_directory (str): A file path to the directory to output all the analyses.
+        conversion_type (list): A list of strings of the conversion types to use in the analysis.
+        strands (list): A list of converstion strands to use in the experiment.
+        model_dir (str): a string representing the file path to the dorado basecalling model directory.
+        model (str): a string representing the dorado basecalling model.
+        input_data_path (str): a string representing the file path to the experiment directory/file containing sequencing data
+        split_dir (str): A string representing the file path to the directory to split the BAMs into.
+        barcode_kit (str): A string representing the barcoding kit used in the experiment.
+        mapping_threshold (float): A value in between 0 and 1 to threshold the minimal fraction of aligned reads which map to the reference region. References with values above the threshold are included in the output adata.
+        experiment_name (str): A string to provide an experiment name to the output adata file.
+        bam_suffix (str): A suffix to add to the bam file.
+        basecall (bool): Whether to go through basecalling or not.
+        barcode_both_ends (bool): Whether to require a barcode detection on both ends for demultiplexing.
+        trim (bool): Whether to trim barcodes, adapters, and primers from read ends.
+        device (str): Device to use for basecalling. auto, metal, cpu, cuda
+        make_bigwigs (bool): Whether to make bigwigs
+        threads (int): cpu threads available for processing.
+        input_already_demuxed (bool): Whether the input files were already demultiplexed
+
+    Returns:
+        final_adata_path (str): Path to the final adata object
+        sorted_output (str): Path to the aligned, sorted BAM
+    """
+    from .helpers import align_and_sort_BAM, aligned_BAM_to_bed, canoncall, converted_BAM_to_adata_II, generate_converted_FASTA, get_chromosome_lengths, demux_and_index_BAM, make_dirs, bam_qc, run_multiqc, split_and_index_BAM
+    import os
+    import glob
+    
+    if basecall:
+        model_basename = os.path.basename(model)
+        model_basename = model_basename.replace('.', '_')
+        bam=f"{output_directory}/{model_basename}_canonical_basecalls"
+    else:
+        bam_base=os.path.basename(input_data_path).split('.bam')[0]
+        bam=os.path.join(output_directory, bam_base)
+    aligned_BAM=f"{bam}_aligned"
+    aligned_sorted_BAM=f"{aligned_BAM}_sorted"
+
+    os.chdir(output_directory)
+    
+    # 1) Convert FASTA file
+    fasta_basename = os.path.basename(fasta)
+    converted_FASTA_basename = fasta_basename.split('.fa')[0]+'_converted.fasta'
+    converted_FASTA = os.path.join(output_directory, converted_FASTA_basename)
+    if 'converted.fa' in fasta:
+        print(fasta + ' is already converted. Using existing converted FASTA.')
+        converted_FASTA = fasta
+    elif os.path.exists(converted_FASTA):
+        print(converted_FASTA + ' already exists. Using existing converted FASTA.')
+    else:
+        generate_converted_FASTA(fasta, conversion_types, strands, converted_FASTA)
+
+    # Make a FAI and .chrom.names file for the converted fasta
+    get_chromosome_lengths(converted_FASTA)
+
+    # 2) Basecall from the input POD5 to generate a singular output BAM
+    if basecall:
+        canoncall_output = bam + bam_suffix
+        if os.path.exists(canoncall_output):
+            print(canoncall_output + ' already exists. Using existing basecalled BAM.')
+        else:
+            canoncall(model_dir, model, input_data_path, barcode_kit, bam, bam_suffix, barcode_both_ends, trim, device)
+    else:
+        canoncall_output = input_data_path
+
+    # 3) Align the BAM to the converted reference FASTA and sort the bam on positional coordinates. Also make an index and a bed file of mapped reads
+    aligned_output = aligned_BAM + bam_suffix
+    sorted_output = aligned_sorted_BAM + bam_suffix
+    if os.path.exists(aligned_output) and os.path.exists(sorted_output):
+        print(sorted_output + ' already exists. Using existing aligned/sorted BAM.')
+    else:
+        align_and_sort_BAM(converted_FASTA, canoncall_output, bam_suffix, output_directory, make_bigwigs, threads)
+
+    # Make beds and provide basic histograms
+    bed_dir = os.path.join(output_directory, 'beds')
+    if os.path.isdir(bed_dir):
+        print(bed_dir + ' already exists. Skipping BAM -> BED conversion for ' + sorted_output)
+    else:
+        aligned_BAM_to_bed(aligned_output, output_directory, converted_FASTA, make_bigwigs, threads)
+
+    ### 4) Split the aligned and sorted BAM files by barcode (BC Tag) into the split_BAM directory###
+    if barcode_both_ends:
+        split_dir = split_dir + '_both_ends_barcoded'
+    else:
+        split_dir = split_dir + '_at_least_one_end_barcoded'
+    
+    if os.path.isdir(split_dir):
+        print(split_dir + ' already exists. Using existing demultiplexed BAMs.')
+        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 and 'unclassified' not in bam]
+        bam_files.sort()
+    else:
+        make_dirs([split_dir])
+        if input_already_demuxed:
+            bam_files = split_and_index_BAM(aligned_sorted_BAM, split_dir, bam_suffix, output_directory) # custom for non-nanopore
+        else:
+            bam_files = demux_and_index_BAM(aligned_sorted_BAM, split_dir, bam_suffix, barcode_kit, barcode_both_ends, trim, fasta, make_bigwigs, threads)
+        
+    # Make beds and provide basic histograms
+    bed_dir = os.path.join(split_dir, 'beds')
+    if os.path.isdir(bed_dir):
+        print(bed_dir + ' already exists. Skipping BAM -> BED conversion for demultiplexed bams')
+    else:
+        for bam in bam_files:
+            aligned_BAM_to_bed(bam, split_dir, converted_FASTA, make_bigwigs, threads)
+
+    # 5) Samtools QC metrics on split BAM files
+    bam_qc_dir = f"{split_dir}/bam_qc"
+    if os.path.isdir(bam_qc_dir):
+        print(bam_qc_dir + ' already exists. Using existing BAM QC calculations.')
+    else:
+        make_dirs([bam_qc_dir])
+        bam_qc(bam_files, bam_qc_dir, threads, modality='conversion')
+
+    # multiqc ###
+    if os.path.isdir(f"{split_dir}/multiqc"):
+        print(f"{split_dir}/multiqc" + ' already exists, skipping multiqc')
+    else:
+        run_multiqc(split_dir, f"{split_dir}/multiqc")
+
+    # 6) Take the converted BAM and load it into an adata object.
+    final_adata, final_adata_path = converted_BAM_to_adata_II(converted_FASTA, split_dir, mapping_threshold, experiment_name, conversion_types, bam_suffix, device)
+
+    return final_adata, final_adata_path, sorted_output, bam_files