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

smftools/hmm/__init__.py

@@ -0,0 +1,20 @@
+from .apply_hmm_batched import apply_hmm_batched
+from .calculate_distances import calculate_distances
+from .call_hmm_peaks import call_hmm_peaks
+from .display_hmm import display_hmm
+from .hmm_readwrite import load_hmm, save_hmm
+from .nucleosome_hmm_refinement import refine_nucleosome_calls, infer_nucleosomes_in_large_bound
+from .train_hmm import train_hmm
+
+
+__all__ = [
+    "apply_hmm_batched",
+    "calculate_distances",
+    "call_hmm_peaks",
+    "display_hmm",
+    "load_hmm",
+    "refine_nucleosome_calls",
+    "infer_nucleosomes_in_large_bound",
+    "save_hmm",
+    "train_hmm"
+]

smftools/{tools → hmm}/apply_hmm_batched.py

@@ -3,14 +3,11 @@ import pandas as pd
 import torch
 from tqdm import tqdm    
 
-def apply_hmm_batched(adata, model, obs_column, layer=None, footprints=True, accessible_patches=False, cpg=False, methbases=["GpC", "CpG", "A"], device="cpu", threshold=0.7):
+def apply_hmm_batched(adata, model, obs_column, layer=None, footprints=True, accessible_patches=False, cpg=False, methbases=["GpC", "CpG", "A", "C"], device="cpu", threshold=0.7, deaminase_footprinting=False):
     """
     Applies an HMM model to an AnnData object using tensor-based sequence inputs.
     If multiple methbases are passed, generates a combined feature set.
     """
-    import numpy as np
-    import torch
-    from tqdm import tqdm
 
     model.to(device)
 
@@ -74,6 +71,7 @@ def apply_hmm_batched(adata, model, obs_column, layer=None, footprints=True, acc
         for methbase in methbases:
             mask = {
                 "a": ref_subset.var[f"{ref}_strand_FASTA_base"] == "A",
+                "c": ref_subset.var[f"{ref}_any_C_site"] == True,
                 "gpc": ref_subset.var[f"{ref}_GpC_site"] == True,
                 "cpg": ref_subset.var[f"{ref}_CpG_site"] == True
             }[methbase.lower()]
@@ -150,6 +148,8 @@ def apply_hmm_batched(adata, model, obs_column, layer=None, footprints=True, acc
                     adata.obs.at[idx, f"CpG_all_cpg_features"].append([start, length, prob])
 
     # --- Binarization + Distance ---
+    coordinates = adata.var_names.astype(int).values
+    
     for feature in tqdm(all_features, desc="Finalizing Layers"):
         bin_matrix = np.zeros((adata.shape[0], adata.shape[1]), dtype=int)
         counts = np.zeros(adata.shape[0], dtype=int)
@@ -158,9 +158,11 @@ def apply_hmm_batched(adata, model, obs_column, layer=None, footprints=True, acc
                 intervals = []
             for start, length, prob in intervals:
                 if prob > threshold:
-                    bin_matrix[row_idx, start:start+length] = 1
+                    start_idx = np.searchsorted(coordinates, start, side="left")
+                    end_idx = np.searchsorted(coordinates, start + length - 1, side="right")
+                    bin_matrix[row_idx, start_idx:end_idx] = 1
                     counts[row_idx] += 1
-        adata.layers[f"{feature}"] = bin_matrix
+        adata.layers[feature] = bin_matrix
         adata.obs[f"n_{feature}"] = counts
         adata.obs[f"{feature}_distances"] = calculate_batch_distances(adata.obs[feature].tolist(), threshold)
 
@@ -202,7 +204,6 @@ def classify_batch(predicted_states_batch, probabilities_batch, coordinates, cla
     Returns:
         List of classifications for each sequence.
     """
-    import numpy as np
 
     state_labels = ["Non-Methylated", "Methylated"]
     target_idx = state_labels.index(target_state)

smftools/hmm/call_hmm_peaks.py

@@ -0,0 +1,106 @@
+def call_hmm_peaks(
+    adata,
+    feature_configs,
+    obs_column='Reference_strand',
+    site_types=['GpC_site', 'CpG_site'],
+    save_plot=False,
+    output_dir=None,
+    date_tag=None,
+    inplace=False
+):
+    import numpy as np
+    import pandas as pd
+    import matplotlib.pyplot as plt
+    from scipy.signal import find_peaks
+
+    if not inplace:
+        adata = adata.copy()
+
+    # Ensure obs_column is categorical
+    if not isinstance(adata.obs[obs_column].dtype, pd.CategoricalDtype):
+        adata.obs[obs_column] = pd.Categorical(adata.obs[obs_column])
+
+    coordinates = adata.var_names.astype(int).values
+    peak_columns = []
+
+    obs_updates = {}
+
+    for feature_layer, config in feature_configs.items():
+        min_distance = config.get('min_distance', 200)
+        peak_width = config.get('peak_width', 200)
+        peak_prominence = config.get('peak_prominence', 0.2)
+        peak_threshold = config.get('peak_threshold', 0.8)
+
+        matrix = adata.layers[feature_layer]
+        means = np.mean(matrix, axis=0)
+        peak_indices, _ = find_peaks(means, prominence=peak_prominence, distance=min_distance)
+        peak_centers = coordinates[peak_indices]
+        adata.uns[f'{feature_layer} peak_centers'] = peak_centers.tolist()
+
+        # Plot
+        plt.figure(figsize=(6, 3))
+        plt.plot(coordinates, means)
+        plt.title(f"{feature_layer} with peak calls")
+        plt.xlabel("Genomic position")
+        plt.ylabel("Mean intensity")
+        for i, center in enumerate(peak_centers):
+            start, end = center - peak_width // 2, center + peak_width // 2
+            plt.axvspan(start, end, color='purple', alpha=0.2)
+            plt.axvline(center, color='red', linestyle='--')
+            aligned = [end if i % 2 else start, 'left' if i % 2 else 'right']
+            plt.text(aligned[0], 0, f"Peak {i}\n{center}", color='red', ha=aligned[1])
+        if save_plot and output_dir:
+            filename = f"{output_dir}/{date_tag or 'output'}_{feature_layer}_peaks.png"
+            plt.savefig(filename, bbox_inches='tight')
+            print(f"Saved plot to {filename}")
+        else:
+            plt.show()
+
+        feature_peak_columns = []
+        for center in peak_centers:
+            start, end = center - peak_width // 2, center + peak_width // 2
+            colname = f'{feature_layer}_peak_{center}'
+            peak_columns.append(colname)
+            feature_peak_columns.append(colname)
+
+            peak_mask = (coordinates >= start) & (coordinates <= end)
+            adata.var[colname] = peak_mask
+
+            region = matrix[:, peak_mask]
+            obs_updates[f'mean_{feature_layer}_around_{center}'] = np.mean(region, axis=1)
+            obs_updates[f'sum_{feature_layer}_around_{center}'] = np.sum(region, axis=1)
+            obs_updates[f'{feature_layer}_present_at_{center}'] = np.mean(region, axis=1) > peak_threshold
+
+            for site_type in site_types:
+                adata.obs[f'{site_type}_sum_around_{center}'] = 0
+                adata.obs[f'{site_type}_mean_around_{center}'] = np.nan
+
+            for ref in adata.obs[obs_column].cat.categories:
+                ref_idx = adata.obs[obs_column] == ref
+                mask_key = f"{ref}_{site_type}"
+                for site_type in site_types:
+                    if mask_key not in adata.var:
+                        continue
+                    site_mask = adata.var[mask_key].values
+                    site_coords = coordinates[site_mask]
+                    region_mask = (site_coords >= start) & (site_coords <= end)
+                    if not region_mask.any():
+                        continue
+                    full_mask = site_mask.copy()
+                    full_mask[site_mask] = region_mask
+                    site_region = adata[ref_idx, full_mask].X
+                    if hasattr(site_region, "A"):
+                        site_region = site_region.A
+                    if site_region.shape[1] > 0:
+                        adata.obs.loc[ref_idx, f'{site_type}_sum_around_{center}'] = np.nansum(site_region, axis=1)
+                        adata.obs.loc[ref_idx, f'{site_type}_mean_around_{center}'] = np.nanmean(site_region, axis=1)
+                    else:
+                        pass
+
+        adata.var[f'is_in_any_{feature_layer}_peak'] = adata.var[feature_peak_columns].any(axis=1)
+        print(f"Annotated {len(peak_centers)} peaks for {feature_layer}")
+
+    adata.var['is_in_any_peak'] = adata.var[peak_columns].any(axis=1)
+    adata.obs = pd.concat([adata.obs, pd.DataFrame(obs_updates, index=adata.obs.index)], axis=1)
+
+    return adata if not inplace else None

smftools/{tools → hmm}/display_hmm.py

@@ -1,16 +1,16 @@
 def display_hmm(hmm, state_labels=["Non-Methylated", "Methylated"], obs_labels=["0", "1"]):
     import torch
-    print("\n🔹 **HMM Model Overview**")
+    print("\n**HMM Model Overview**")
     print(hmm)
 
-    print("\n🔹 **Transition Matrix**")
+    print("\n**Transition Matrix**")
     transition_matrix = torch.exp(hmm.edges).detach().cpu().numpy()
     for i, row in enumerate(transition_matrix):
         label = state_labels[i] if state_labels else f"State {i}"
         formatted_row = ", ".join(f"{p:.6f}" for p in row)
         print(f"{label}: [{formatted_row}]")
 
-    print("\n🔹 **Emission Probabilities**")
+    print("\n**Emission Probabilities**")
     for i, dist in enumerate(hmm.distributions):
         label = state_labels[i] if state_labels else f"State {i}"
         probs = dist.probs.detach().cpu().numpy()

smftools/{tools → hmm}/nucleosome_hmm_refinement.py

@@ -56,7 +56,7 @@ def refine_nucleosome_calls(adata, layer_name, nan_mask_layer, hexamer_size=120,
     adata.layers[f"{layer_name}_hexamers"] = hexamer_layer
     adata.layers[f"{layer_name}_octamers"] = octamer_layer
 
-    print(f"✅ Added layers: {layer_name}_hexamers and {layer_name}_octamers")
+    print(f"Added layers: {layer_name}_hexamers and {layer_name}_octamers")
     return adata
 
 def infer_nucleosomes_in_large_bound(adata, large_bound_layer, combined_nuc_layer, nan_mask_layer, nuc_size=147, linker_size=50, exclusion_buffer=30, device="cpu"):
@@ -100,5 +100,5 @@ def infer_nucleosomes_in_large_bound(adata, large_bound_layer, combined_nuc_laye
                         pos_cursor += 1
 
     adata.layers[f"{large_bound_layer}_phased_nucleosomes"] = inferred_layer
-    print(f"✅ Added layer: {large_bound_layer}_phased_nucleosomes")
+    print(f"Added layer: {large_bound_layer}_phased_nucleosomes")
     return adata

smftools/{tools → hmm}/train_hmm.py

@@ -11,7 +11,7 @@ def train_hmm(
     pad_value=0,
 ):
     """
-    Trains a 2-state DenseHMM model on binary methylation data.
+    Trains a 2-state DenseHMM model on binary methylation/deamination data.
 
     Parameters:
         data (list or np.ndarray): List of sequences (lists) with 0, 1, or NaN.

smftools/informatics/__init__.py

@@ -1,16 +1,20 @@
-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
-
+from .bam_functions import align_and_sort_BAM, bam_qc, concatenate_fastqs_to_bam, count_aligned_reads, demux_and_index_BAM, extract_base_identities, extract_read_features_from_bam, extract_readnames_from_bam, separate_bam_by_bc, split_and_index_BAM
+from .basecalling import canoncall, modcall
+from .bed_functions import aligned_BAM_to_bed, _bed_to_bigwig, extract_read_lengths_from_bed, _plot_bed_histograms
+from .converted_BAM_to_adata import converted_BAM_to_adata
+from .fasta_functions import find_conversion_sites, generate_converted_FASTA, get_chromosome_lengths, get_native_references, index_fasta, subsample_fasta_from_bed
+from .h5ad_functions import add_demux_type_annotation, add_read_length_and_mapping_qc
+from .modkit_functions import extract_mods, make_modbed, modQC
+from .modkit_extract_to_adata import modkit_extract_to_adata
+from .ohe import one_hot_encode, one_hot_decode, ohe_layers_decode, ohe_batching
+from .pod5_functions import basecall_pod5s, fast5_to_pod5, subsample_pod5
+from .run_multiqc import run_multiqc
 
 __all__ = [
     "basecall_pod5s",
-    "load_adata",
+    "converted_BAM_to_adata",
     "subsample_fasta_from_bed",
     "subsample_pod5",
     "fast5_to_pod5",
-    "helpers"
+    "run_multiqc"
 ]

smftools/informatics/archived/deaminase_smf.py

@@ -0,0 +1,132 @@
+
+def deaminase_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 shutil
+    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 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, deaminase_alignment=True)
+
+    # 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, deaminase_footprinting=True)
+
+    return final_adata, final_adata_path, sorted_output, bam_files

smftools/informatics/archived/fast5_to_pod5.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+import subprocess
+from typing import Union, List
+
+def fast5_to_pod5(
+    fast5_dir: Union[str, Path, List[Union[str, Path]]],
+    output_pod5: Union[str, Path] = "FAST5s_to_POD5.pod5"
+) -> None:
+    """
+    Convert Nanopore FAST5 files (single file, list of files, or directory)
+    into a single .pod5 output using the 'pod5 convert fast5' CLI tool.
+    """
+
+    output_pod5 = str(output_pod5)  # ensure string
+
+    # 1) If user gives a list of FAST5 files
+    if isinstance(fast5_dir, (list, tuple)):
+        fast5_paths = [str(Path(f)) for f in fast5_dir]
+        cmd = ["pod5", "convert", "fast5", *fast5_paths, "--output", output_pod5]
+        subprocess.run(cmd, check=True)
+        return
+
+    # Ensure Path object
+    p = Path(fast5_dir)
+
+    # 2) If user gives a single file
+    if p.is_file():
+        cmd = ["pod5", "convert", "fast5", str(p), "--output", output_pod5]
+        subprocess.run(cmd, check=True)
+        return
+
+    # 3) If user gives a directory → collect FAST5s
+    if p.is_dir():
+        fast5_paths = sorted(str(f) for f in p.glob("*.fast5"))
+        if not fast5_paths:
+            raise FileNotFoundError(f"No FAST5 files found in {p}")
+
+        cmd = ["pod5", "convert", "fast5", *fast5_paths, "--output", output_pod5]
+        subprocess.run(cmd, check=True)
+        return
+
+    raise FileNotFoundError(f"Input path invalid: {fast5_dir}")
+

smftools/informatics/archived/helpers/archived/__init__.py

@@ -0,0 +1,71 @@
+# from .align_and_sort_BAM import align_and_sort_BAM
+# from .aligned_BAM_to_bed import aligned_BAM_to_bed
+# from .bam_qc import bam_qc
+# 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_II import converted_BAM_to_adata_II
+# from .concatenate_fastqs_to_bam import concatenate_fastqs_to_bam
+# from .count_aligned_reads import count_aligned_reads
+# from .demux_and_index_BAM import demux_and_index_BAM
+# from .discover_input_files import *
+# from .extract_base_identities import extract_base_identities
+# from .extract_mods import extract_mods
+# from .extract_read_features_from_bam import extract_read_features_from_bam
+# from .extract_read_lengths_from_bed import extract_read_lengths_from_bed
+# 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 .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 .one_hot_decode import one_hot_decode
+# from .ohe_layers_decode import ohe_layers_decode
+# from .plot_bed_histograms import plot_bed_histograms
+# from .run_multiqc import run_multiqc
+# 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",
+#     "bam_qc",
+#     "bed_to_bigwig",
+#     "binarize_converted_base_identities",
+#     "canoncall",
+#     "complement_base_list",
+#     "converted_BAM_to_adata_II",
+#     "concatenate_fastqs_to_bam",
+#     "count_aligned_reads",
+#     "demux_and_index_BAM",
+#     "extract_base_identities",
+#     "extract_mods",
+#     "extract_read_features_from_bam",
+#     "extract_read_lengths_from_bed",
+#     "extract_readnames_from_BAM",
+#     "find_conversion_sites",
+#     "convert_FASTA_record",
+#     "generate_converted_FASTA",
+#     "get_chromosome_lengths",
+#     "get_native_references",
+#     "index_fasta",
+#     "make_modbed",
+#     "modcall",
+#     "modkit_extract_to_adata",
+#     "modQC",
+#     "one_hot_encode",
+#     "ohe_batching",
+#     "one_hot_decode",
+#     "ohe_layers_decode",
+#     "plot_bed_histograms",
+#     "run_multiqc",
+#     "separate_bam_by_bc",
+#     "split_and_index_BAM"
+# ]

smftools/informatics/archived/helpers/archived/align_and_sort_BAM.py

@@ -0,0 +1,126 @@
+from pathlib import Path
+import os
+import subprocess
+from typing import List, Optional, Union
+import pysam
+
+def _bam_to_fastq_with_pysam(bam_path: Union[str, Path], fastq_path: Union[str, Path]) -> None:
+    """
+    Minimal BAM->FASTQ using pysam. Writes unmapped or unaligned reads as-is.
+    """
+    bam_path = str(bam_path)
+    fastq_path = str(fastq_path)
+    with pysam.AlignmentFile(bam_path, "rb", check_sq=False) as bam, open(fastq_path, "w") as fq:
+        for r in bam.fetch(until_eof=True):
+            # Skip secondary/supplementary if you want (optional):
+            # if r.is_secondary or r.is_supplementary: continue
+            name = r.query_name
+            seq = r.query_sequence or ""
+            qual = r.qual or ""
+            fq.write(f"@{name}\n{seq}\n+\n{qual}\n")
+
+def _sort_bam_with_pysam(in_bam: Union[str, Path], out_bam: Union[str, Path], threads: Optional[int] = None) -> None:
+    in_bam, out_bam = str(in_bam), str(out_bam)
+    args = []
+    if threads:
+        args += ["-@", str(threads)]
+    args += ["-o", out_bam, in_bam]
+    pysam.sort(*args)
+
+def _index_bam_with_pysam(bam_path: Union[str, Path], threads: Optional[int] = None) -> None:
+    bam_path = str(bam_path)
+    # pysam.index supports samtools-style args
+    if threads:
+        pysam.index("-@", str(threads), bam_path)
+    else:
+        pysam.index(bam_path)
+
+def align_and_sort_BAM(fasta, 
+                       input, 
+                       bam_suffix='.bam', 
+                       output_directory='aligned_outputs', 
+                       make_bigwigs=False, 
+                       threads=None, 
+                       aligner='minimap2',
+                       aligner_args=['-a', '-x', 'map-ont', '--MD', '-Y', '-y', '-N', '5', '--secondary=no']):
+    """
+    A wrapper for running dorado aligner and samtools functions
+    
+    Parameters:
+        fasta (str): File path to the reference genome to align to.
+        input (str): File path to the basecalled file to align. Works for .bam and .fastq files
+        bam_suffix (str): The suffix to use for the BAM file.
+        output_directory (str): A file path to the directory to output all the analyses.
+        make_bigwigs (bool): Whether to make bigwigs
+        threads (int): Number of additional threads to use
+        aligner (str): Aligner to use. minimap2 and dorado options
+        aligner_args (list): list of optional parameters to use for the alignment
+
+    Returns:
+        None
+            The function writes out files for: 1) An aligned BAM, 2) and aligned_sorted BAM, 3) an index file for the aligned_sorted BAM, 4) A bed file for the aligned_sorted BAM, 5) A text file containing read names in the aligned_sorted BAM
+    """
+    input_basename = input.name
+    input_suffix = input.suffix
+    input_as_fastq = input.with_name(input.stem + '.fastq')
+
+    output_path_minus_suffix = output_directory / input.stem
+    
+    aligned_BAM = output_path_minus_suffix.with_name(output_path_minus_suffix.stem + "_aligned")
+    aligned_output = aligned_BAM.with_suffix(bam_suffix)
+    aligned_sorted_BAM =aligned_BAM.with_name(aligned_BAM.stem + "_sorted")
+    aligned_sorted_output = aligned_sorted_BAM.with_suffix(bam_suffix)
+
+    if threads:
+        threads = str(threads)
+    else:
+        pass
+    
+    if aligner == 'minimap2':
+        print(f"Converting BAM to FASTQ: {input}")
+        _bam_to_fastq_with_pysam(input, input_as_fastq)
+        # bam_to_fastq_command = ['samtools', 'fastq', input]
+        # subprocess.run(bam_to_fastq_command, stdout=open(input_as_fastq, "w"))
+        print(f"Aligning FASTQ to Reference: {input_as_fastq}")
+        if threads:
+            minimap_command = ['minimap2'] + aligner_args + ['-t', threads, str(fasta), str(input_as_fastq)]
+        else:
+            minimap_command = ['minimap2'] + aligner_args + [str(fasta), str(input_as_fastq)]
+        subprocess.run(minimap_command, stdout=open(aligned_output, "w"))
+        os.remove(input_as_fastq)
+
+    elif aligner == 'dorado':
+        # Run dorado aligner
+        print(f"Aligning BAM to Reference: {input}")
+        if threads:
+            alignment_command = ["dorado", "aligner", "-t", threads] + aligner_args + [str(fasta), str(input)]
+        else:
+            alignment_command = ["dorado", "aligner"] + aligner_args + [str(fasta), str(input)]
+        subprocess.run(alignment_command, stdout=open(aligned_output, "wb"))
+
+    else:
+        print(f'Aligner not recognized: {aligner}. Choose from minimap2 and dorado')
+        return
+    
+    # --- Sort & Index with pysam ---
+    print(f"[pysam] Sorting: {aligned_output} -> {aligned_sorted_output}")
+    _sort_bam_with_pysam(aligned_output, aligned_sorted_output, threads=threads)
+
+    print(f"[pysam] Indexing: {aligned_sorted_output}")
+    _index_bam_with_pysam(aligned_sorted_output, threads=threads)
+
+    # Sort the BAM on positional coordinates
+    # print(f"Sorting BAM: {aligned_output}")
+    # if threads:
+    #     sort_command = ["samtools", "sort", "-@", threads, "-o", aligned_sorted_output, aligned_output]
+    # else:
+    #     sort_command = ["samtools", "sort", "-o", aligned_sorted_output, aligned_output]
+    # subprocess.run(sort_command)
+
+    # # Create a BAM index file
+    # print(f"Indexing BAM: {aligned_sorted_output}")
+    # if threads:
+    #     index_command = ["samtools", "index", "-@", threads, aligned_sorted_output]
+    # else:
+    #     index_command = ["samtools", "index", aligned_sorted_output]
+    # subprocess.run(index_command)