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

smftools/_settings.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from typing import Union
 
 class SMFConfig:
     """\
@@ -8,9 +9,9 @@ class SMFConfig:
     def __init__(
         self,
         *,
-        datasetdir: Path | str = "./datasets/"
+        datasetdir: Union[Path, str] = "./datasets/"
     ):
-         self._datasetdir = Path(datasetdir) if isinstance(datasetdir, str) else datasetdir
+        self._datasetdir = Path(datasetdir) if isinstance(datasetdir, str) else datasetdir
 
     @property
     def datasetdir(self) -> Path:

smftools/_version.py

@@ -1 +1 @@
-__version__ = "0.1.1"
+__version__ = "0.1.3"

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/datasets.py

@@ -1,10 +1,9 @@
 ## datasets
 
-def import_deps():
+def import_HERE():
     """
-    
+    Imports HERE for loading datasets
     """
-    import anndata as ad
     from pathlib import Path
     from .._settings import settings
     HERE = Path(__file__).parent
@@ -12,16 +11,18 @@ def import_deps():
 
 def dCas9_kinetics():
     """
-    
+    in vitro Hia5 dCas9 kinetics SMF dataset. Nanopore HAC m6A modcalls.
     """
-    HERE = import_deps()
+    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.
     """
-    HERE = import_deps()
+    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

@@ -1,12 +1,14 @@
-from .pod5_to_adata import pod5_to_adata
-from .basecalls_to_adata import basecalls_to_adata
+from . import helpers
+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__ = [
-    "pod5_to_adata",
-    "basecalls_to_adata",
+    "load_adata",
+    "subsample_fasta_from_bed",
     "subsample_pod5",
-    "fast5_to_pod5"
+    "fast5_to_pod5",
+    "helpers"
 ]

smftools/informatics/{bam_conversion.py → archived/bam_conversion.py}

@@ -18,7 +18,7 @@ def bam_conversion(fasta, output_directory, conversion_types, strands, basecalle
     Returns:
         None
     """
-    from .helpers import align_and_sort_BAM, converted_BAM_to_adata, generate_converted_FASTA, split_and_index_BAM
+    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]
@@ -32,16 +32,28 @@ def bam_conversion(fasta, output_directory, conversion_types, strands, basecalle
     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 os.path.exists(converted_FASTA):
+    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
-    align_and_sort_BAM(converted_FASTA, basecalled_path, bam_suffix, output_directory)
+    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###
-    split_and_index_BAM(aligned_sorted_BAM, split_dir, bam_suffix)
+    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/{bam_direct.py → archived/bam_direct.py}

@@ -29,8 +29,7 @@ def bam_direct(fasta, output_directory, mod_list, thresholds, bam_path, split_di
     mod_bed_dir=f"{output_directory}/split_mod_beds"
     mod_tsv_dir=f"{output_directory}/split_mod_tsvs"
 
-    make_dirs([mod_bed_dir, mod_tsv_dir])
-
+    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]
@@ -38,12 +37,27 @@ def bam_direct(fasta, output_directory, mod_list, thresholds, bam_path, split_di
     os.chdir(output_directory)
 
     # 1) Align the BAM to the reference FASTA. Also make an index and a bed file of mapped reads
-    align_and_sort_BAM(fasta, bam_path, bam_suffix, output_directory)
+    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
-    split_and_index_BAM(aligned_sorted_BAM, split_dir, bam_suffix)
+    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 ###
-    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
-    extract_mods(thresholds, mod_tsv_dir, split_dir, bam_suffix) # Extract methylations calls for split BAM files into split TSV 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, aligned_sorted_output, mapping_threshold, experiment_name, mods, batch_size)
+    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/conversion_smf.py

@@ -0,0 +1,79 @@
+## conversion_smf
+
+def conversion_smf(fasta, output_directory, conversion_types, strands, model, input_data_path, split_dir, barcode_kit, mapping_threshold, experiment_name, bam_suffix, basecall):
+    """
+    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 (str): a string representing the file path to 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.
+
+    Returns:
+        None
+    """
+    from .helpers import align_and_sort_BAM, canoncall, converted_BAM_to_adata, generate_converted_FASTA, get_chromosome_lengths, split_and_index_BAM, make_dirs
+    import os
+    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, input_data_path, barcode_kit, bam, bam_suffix)
+    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)
+
+    ### 4) 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, converted_FASTA)
+
+    # 5) 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/direct_smf.py

@@ -0,0 +1,89 @@
+## direct_smf
+
+def direct_smf(fasta, output_directory, mod_list, model, thresholds, input_data_path, split_dir, barcode_kit, mapping_threshold, experiment_name, bam_suffix, batch_size, basecall):
+    """
+    Processes sequencing data from a direct methylation detection Nanopore SMF experiment to an AnnData 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.
+        model (str): a string representing the file path to the dorado basecalling model.
+        thresholds (list): A list of floats to pass for call thresholds.
+        input_data_path (str): a string representing the file path to the experiment directory containing the input sequencing files.
+        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.
+        batch_size (int): An integer number of TSV files to analyze in memory at once while loading the final adata object.
+        basecall (bool): Whether to basecall
+
+    Returns:
+        None   
+    """
+    from .helpers import align_and_sort_BAM, extract_mods, get_chromosome_lengths, make_modbed, modcall, modkit_extract_to_adata, modQC, split_and_index_BAM, make_dirs
+    import os
+
+    if basecall:
+        model_basename = os.path.basename(model)
+        model_basename = model_basename.replace('.', '_')
+        mod_string = "_".join(mod_list)
+        bam=f"{output_directory}/{model_basename}_{mod_string}_calls"
+    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"
+    mod_bed_dir=f"{output_directory}/split_mod_beds"
+    mod_tsv_dir=f"{output_directory}/split_mod_tsvs"
+
+    aligned_sorted_output = aligned_sorted_BAM + bam_suffix
+    mod_map = {'6mA': '6mA', '5mC_5hmC': '5mC'}
+    mods = [mod_map[mod] for mod in mod_list]
+
+    # Make a FAI and .chrom.names file for the fasta
+    get_chromosome_lengths(fasta)
+
+    os.chdir(output_directory)
+
+    # 1) Basecall using dorado
+    if basecall:
+        modcall_output = bam + bam_suffix
+        if os.path.exists(modcall_output):
+            print(modcall_output + ' already exists. Using existing basecalled BAM.')
+        else:
+            modcall(model, input_data_path, barcode_kit, mod_list, bam, bam_suffix)
+    else:
+        modcall_output = input_data_path
+
+    # 2) Align the BAM to the reference FASTA. 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(fasta, modcall_output, 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, fasta)
+
+    # 4) 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
+
+    #5 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/fast5_to_pod5.py

@@ -1,19 +1,21 @@
 # fast5_to_pod5
 
-def fast5_to_pod5(fast5_dir, output_dir='outputs/', output_pod5='FAST5s_to_POD5.pod5'):
+def fast5_to_pod5(fast5_dir, output_pod5='FAST5s_to_POD5.pod5'):
     """
     Convert Nanopore FAST5 files to POD5 file
 
     Parameters:
         fast5_dir (str): String representing the file path to a directory containing all FAST5 files to convert into a single POD5 output.
-        output_dir (str): String representing the file path to the output directory.
-        output_pod5 (str): The name of the output POD5 to write out within the output directory.
+        output_pod5 (str): The name of the output POD5.
     
     Returns:
         None
     
     """
     import subprocess
-    import os
-    pod5 = os.path.join(output_dir, output_pod5)
-    subprocess.run(["pod5", "convert", "fast5", f".{fast5_dir}*.fast5", "--output", pod5])
+    from pathlib import Path
+
+    if Path(fast5_dir).is_file():
+        subprocess.run(["pod5", "convert", "fast5", fast5_dir, "--output", output_pod5])
+    elif Path(fast5_dir).is_dir():
+        subprocess.run(["pod5", "convert", "fast5", f".{fast5_dir}*.fast5", "--output", output_pod5])

smftools/informatics/helpers/__init__.py

@@ -1,13 +1,20 @@
 from .align_and_sort_BAM import align_and_sort_BAM
+from .aligned_BAM_to_bed import aligned_BAM_to_bed
+from .bed_to_bigwig import bed_to_bigwig
 from .binarize_converted_base_identities import binarize_converted_base_identities
 from .canoncall import canoncall
+from .complement_base_list import complement_base_list
 from .converted_BAM_to_adata import converted_BAM_to_adata
+from .concatenate_fastqs_to_bam import concatenate_fastqs_to_bam
 from .count_aligned_reads import count_aligned_reads
 from .extract_base_identities import extract_base_identities
 from .extract_mods import extract_mods
+from .extract_readnames_from_BAM import extract_readnames_from_BAM
 from .find_conversion_sites import find_conversion_sites
 from .generate_converted_FASTA import convert_FASTA_record, generate_converted_FASTA
+from .get_chromosome_lengths import get_chromosome_lengths
 from .get_native_references import get_native_references
+from .index_fasta import index_fasta
 from .LoadExperimentConfig import LoadExperimentConfig
 from .make_dirs import make_dirs
 from .make_modbed import make_modbed
@@ -15,21 +22,30 @@ from .modcall import modcall
 from .modkit_extract_to_adata import modkit_extract_to_adata
 from .modQC import modQC
 from .one_hot_encode import one_hot_encode
+from .ohe_batching import ohe_batching
+from .plot_read_length_and_coverage_histograms import plot_read_length_and_coverage_histograms
 from .separate_bam_by_bc import separate_bam_by_bc
 from .split_and_index_BAM import split_and_index_BAM
 
 __all__ = [
     "align_and_sort_BAM",
+    "aligned_BAM_to_bed",
+    "bed_to_bigwig",
     "binarize_converted_base_identities",
     "canoncall",
+    "complement_base_list",
     "converted_BAM_to_adata",
+    "concatenate_fastqs_to_bam",
     "count_aligned_reads",
     "extract_base_identities",
     "extract_mods",
+    "extract_readnames_from_BAM",
     "find_conversion_sites",
     "convert_FASTA_record",
     "generate_converted_FASTA",
+    "get_chromosome_lengths",
     "get_native_references",
+    "index_fasta",
     "LoadExperimentConfig",
     "make_dirs",
     "make_modbed",
@@ -37,6 +53,8 @@ __all__ = [
     "modkit_extract_to_adata",
     "modQC",
     "one_hot_encode",
+    "ohe_batching",
+    "plot_read_length_and_coverage_histograms",
     "separate_bam_by_bc",
     "split_and_index_BAM"
 ]

smftools/informatics/helpers/align_and_sort_BAM.py

@@ -16,6 +16,9 @@ def align_and_sort_BAM(fasta, input, bam_suffix, output_directory):
     """
     import subprocess
     import os
+    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
     input_basename = os.path.basename(input)
     input_suffix = '.' + input_basename.split('.')[1]
 
@@ -27,7 +30,7 @@ def align_and_sort_BAM(fasta, input, bam_suffix, output_directory):
     aligned_sorted_output = aligned_sorted_BAM + bam_suffix
     
     # Run dorado aligner
-    subprocess.run(["dorado", "aligner", "--secondary=no", fasta, input], stdout=open(aligned_output, "w"))
+    subprocess.run(["dorado", "aligner", "--secondary", "no", fasta, input], stdout=open(aligned_output, "w"))
 
     # Sort the BAM on positional coordinates
     subprocess.run(["samtools", "sort", "-o", aligned_sorted_output, aligned_output])
@@ -36,17 +39,10 @@ def align_and_sort_BAM(fasta, input, bam_suffix, output_directory):
     subprocess.run(["samtools", "index", aligned_sorted_output])
 
     # Make a bed file of coordinates for the BAM
-    samtools_view = subprocess.Popen(["samtools", "view", aligned_sorted_output], stdout=subprocess.PIPE) 
-    with open(f"{aligned_sorted_BAM}_bed.bed", "w") as output_file:
-        awk_process = subprocess.Popen(["awk", '{print $3, $4, $4+length($10)-1}'], stdin=samtools_view.stdout, stdout=output_file)    
-    samtools_view.stdout.close()
-    awk_process.wait()
-    samtools_view.wait()
+    plotting_dir = os.path.join(output_directory, 'coverage_and_readlength_histograms')
+    bed_dir = os.path.join(output_directory, 'read_alignment_coordinates')
+    make_dirs([plotting_dir, bed_dir])
+    aligned_BAM_to_bed(aligned_sorted_output, plotting_dir, bed_dir, fasta)
 
     # Make a text file of reads for the BAM
-    samtools_view = subprocess.Popen(["samtools", "view", aligned_sorted_output], stdout=subprocess.PIPE)
-    with open(f"{aligned_sorted_BAM}_read_names.txt", "w") as output_file:
-        cut_process = subprocess.Popen(["cut", "-f1"], stdin=samtools_view.stdout, stdout=output_file)   
-    samtools_view.stdout.close()
-    cut_process.wait()
-    samtools_view.wait()
+    extract_readnames_from_BAM(aligned_sorted_output)

smftools/informatics/helpers/aligned_BAM_to_bed.py

@@ -0,0 +1,73 @@
+# aligned_BAM_to_bed
+
+def aligned_BAM_to_bed(aligned_BAM, plotting_dir, bed_dir, fasta):
+    """
+    Takes an aligned BAM as input and writes a bed file of reads as output.
+    Bed columns are: Record name, start position, end position, read length, read name
+
+    Parameters:
+        aligned_BAM (str): Path to an input aligned_BAM to extract to a BED file.
+        plotting_dir (str): Path to write out read alignment length and coverage histograms
+        bed_dir (str): Path to write out read alignment coordinates
+        fasta (str): File path to the reference genome to align to.
+
+    Returns:
+        None
+
+    """
+    import subprocess
+    import os
+    from .bed_to_bigwig import bed_to_bigwig
+    from .plot_read_length_and_coverage_histograms import plot_read_length_and_coverage_histograms
+
+    bed_output_basename = os.path.basename(aligned_BAM).split('.bam')[0] + '_bed.bed'
+    bed_output = os.path.join(bed_dir, bed_output_basename)
+
+    samtools_view = subprocess.Popen(["samtools", "view", aligned_BAM], stdout=subprocess.PIPE) 
+    with open(bed_output, "w") as output_file:
+        awk_process = subprocess.Popen(["awk", '{print $3 "\t" $4 "\t" $4+length($10)-1 "\t" length($10)-1 "\t" $1}'], stdin=samtools_view.stdout, stdout=output_file)    
+    samtools_view.stdout.close()
+    awk_process.wait()
+    samtools_view.wait()
+
+    def split_bed(bed, delete_input=True):
+        """
+        Reads in a BED file and splits it into two separate BED files based on alignment status.
+
+        Parameters:
+            bed (str): Path to the input BED file.
+            delete_input (bool): Whether to delete the input bed file
+
+        Returns:
+            aligned (str): Path to the aligned bed file
+        """
+        unaligned = bed.split('.bed')[0] + '_unaligned.bed'
+        aligned = bed.split('.bed')[0] + '_aligned.bed'
+        
+        with open(bed, 'r') as infile, \
+            open(unaligned, 'w') as unaligned_outfile, \
+            open(aligned, 'w') as aligned_outfile:
+            
+            for line in infile:
+                fields = line.strip().split('\t')
+                
+                if fields[0] == '*':
+                    unaligned_outfile.write(line)
+                else:
+                    aligned_outfile.write(line)
+
+        if delete_input:
+            os.remove(bed)
+        
+        return aligned
+    
+    aligned_bed = split_bed(bed_output)
+
+    # Write out basic plots of reference coverage and read lengths
+    plot_read_length_and_coverage_histograms(aligned_bed, plotting_dir)
+
+    # Make a bedgraph and bigwig for the aligned reads
+    bed_to_bigwig(fasta, aligned_bed)
+
+
+

smftools/informatics/helpers/bed_to_bigwig.py

@@ -0,0 +1,39 @@
+# bed_to_bigwig
+
+def bed_to_bigwig(fasta, bed):
+    """
+    Takes a bed file of reads and makes a bedgraph plus a bigwig
+
+    Parameters:
+        fasta (str): File path to the reference genome to align to.
+        bed (str): File path to the input bed.
+    Returns:
+        None
+    """
+    import os
+    import subprocess
+
+    bed_basename = os.path.basename(bed)
+    parent_dir = os.path.dirname(bed)
+    bed_basename_minus_suffix = bed_basename.split('.bed')[0]
+    fasta_basename = os.path.basename(fasta)
+    fasta_dir = os.path.dirname(fasta)
+    fasta_basename_minus_suffix = fasta_basename.split('.fa')[0]
+    chrom_basename = fasta_basename_minus_suffix + '.chrom.sizes'
+    chrom_path = os.path.join(fasta_dir, chrom_basename)
+    bedgraph_basename = bed_basename_minus_suffix + '_bedgraph.bedgraph'
+    bedgraph_output = os.path.join(parent_dir, bedgraph_basename)
+    bigwig_basename = bed_basename_minus_suffix + '_bigwig.bw'
+    bigwig_output = os.path.join(parent_dir, bigwig_basename)
+
+    # Make the bedgraph
+    with open(bedgraph_output, 'w') as outfile:
+        # Command as a list
+        command = ["bedtools", "genomecov", "-i", bed, "-g", chrom_path, "-bg"]
+        print(f'Making bedgraph from {bed_basename}')
+        subprocess.run(command, stdout=outfile)
+
+    # Make the bigwig
+    command = ["bedGraphToBigWig", bedgraph_output, chrom_path, bigwig_output]
+    print(f'Making bigwig from {bedgraph_basename}')
+    subprocess.run(command)