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

smftools/__init__.py

@@ -3,7 +3,6 @@
 import logging
 import warnings
 
-from anndata import AnnData
 from . import informatics as inform
 from . import preprocessing as pp
 from . import tools as tl
@@ -17,7 +16,6 @@ package_name = "smftools"
 __version__ = version(package_name)
 
 __all__ = [
-    "AnnData",
     "inform",
     "pp",
     "tl",

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 = datasetdir
+        self._datasetdir = Path(datasetdir) if isinstance(datasetdir, str) else datasetdir
 
     @property
     def datasetdir(self) -> Path:

smftools/_version.py

@@ -0,0 +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,25 +1,28 @@
 ## datasets
 
-import numpy as np
-import pandas as pd
-import anndata as ad
-from pathlib import Path
-
-from .._settings import settings
-
-HERE = Path(__file__).parent
-
+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

@@ -1,11 +1,14 @@
 from . import helpers
-from .pod5_conversion import pod5_conversion
-from .pod5_direct import pod5_direct
-from .pod5_to_adata import pod5_to_adata
+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__ = [
-    "helpers",
-    "pod5_conversion",
-    "pod5_direct"
-    "pod5_to_adata"
+    "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/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

@@ -0,0 +1,21 @@
+# fast5_to_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_pod5 (str): The name of the output POD5.
+    
+    Returns:
+        None
+    
+    """
+    import subprocess
+    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/LoadExperimentConfig.py

@@ -0,0 +1,74 @@
+## LoadExperimentConfig
+
+class LoadExperimentConfig:
+    """
+    Loads in the experiment configuration csv and saves global variables with experiment configuration parameters.
+    Parameters:
+        experiment_config (str): A string representing the file path to the experiment configuration csv file.
+    
+    Attributes:
+        var_dict (dict): A dictionary containing experiment configuration parameters.
+
+    Example:
+        >>> import pandas as pd
+        >>> from io import StringIO
+        >>> csv_data = '''variable,value,type
+        ... mapping_threshold,0.05,float
+        ... batch_size,4,int
+        ... testing_bool,True,bool
+        ... strands,"[bottom, top]",list
+        ... split_dir,split_bams,string
+        ... pod5_dir,None,string
+        ... pod5_dir,,string
+        ... '''
+        >>> csv_file = StringIO(csv_data)
+        >>> df = pd.read_csv(csv_file)
+        >>> df.to_csv('test_config.csv', index=False)
+        >>> config_loader = LoadExperimentConfig('test_config.csv')
+        >>> config_loader.var_dict['mapping_threshold']
+        0.05
+        >>> config_loader.var_dict['batch_size']
+        4
+        >>> config_loader.var_dict['testing_bool']
+        True
+        >>> config_loader.var_dict['strands']
+        ['bottom', 'top']
+        >>> config_loader.var_dict['split_dir']
+        'split_bams'
+        >>> config_loader.var_dict['pod5_dir'] is None
+        True
+        >>> config_loader.var_dict['pod5_dir'] is None
+        True
+    """
+    def __init__(self, experiment_config):
+        import pandas as pd
+        # Read the CSV into a pandas DataFrame
+        df = pd.read_csv(experiment_config)
+        # Initialize an empty dictionary to store variables
+        var_dict = {}
+        # Iterate through each row in the DataFrame
+        for _, row in df.iterrows():
+            var_name = str(row['variable'])
+            value = row['value']
+            dtype = row['type']
+            # Handle empty and None values
+            if pd.isna(value) or value in ['None', '']:
+                value = None
+            else:
+                # Handle different data types
+                if dtype == 'list':
+                    # Convert the string representation of a list to an actual list
+                    value = value.strip('()[]').replace(', ', ',').split(',')
+                elif dtype == 'int':
+                    value = int(value)
+                elif dtype == 'float':
+                    value = float(value)
+                elif dtype == 'bool':
+                    value = value.lower() == 'true'
+                elif dtype == 'string':
+                    value = str(value)
+            # Store the variable in the dictionary
+            var_dict[var_name] = value
+        # Save the dictionary as an attribute of the class
+        self.var_dict = var_dict
+

smftools/informatics/helpers/__init__.py

@@ -1,42 +1,60 @@
-from .align_BAM import align_BAM
+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 .load_experiment_config import load_experiment_config
+from .index_fasta import index_fasta
+from .LoadExperimentConfig import LoadExperimentConfig
 from .make_dirs import make_dirs
 from .make_modbed import make_modbed
 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_BAM",
+    "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",
-    "load_experiment_config",
+    "index_fasta",
+    "LoadExperimentConfig",
     "make_dirs",
     "make_modbed",
     "modcall",
     "modkit_extract_to_adata",
     "modQC",
     "one_hot_encode",
+    "ohe_batching",
+    "plot_read_length_and_coverage_histograms",
     "separate_bam_by_bc",
     "split_and_index_BAM"
 ]