smftools 0.2.1__py3-none-any.whl → 0.2.4__py3-none-any.whl

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)

smftools/informatics/{helpers → archived/helpers/archived}/aligned_BAM_to_bed.py

@@ -15,22 +15,23 @@ def aligned_BAM_to_bed(aligned_BAM, out_dir, fasta, make_bigwigs, threads=None):
     """
     import subprocess
     import os
+    from pathlib import Path
     import pysam
     import numpy as np
     import concurrent.futures
     from concurrent.futures import ProcessPoolExecutor
     from .bed_to_bigwig import bed_to_bigwig
-    from . import make_dirs
+    from ...readwrite import make_dirs
     from .plot_bed_histograms import plot_bed_histograms
 
     threads = threads or os.cpu_count()  # Use max available cores if not specified
 
     # Create necessary directories
-    plotting_dir = os.path.join(out_dir, "bed_cov_histograms")
-    bed_dir = os.path.join(out_dir, "beds")
+    plotting_dir = out_dir / "bed_cov_histograms"
+    bed_dir = out_dir / "beds"
     make_dirs([plotting_dir, bed_dir])
 
-    bed_output = os.path.join(bed_dir, os.path.basename(aligned_BAM).replace(".bam", "_bed.bed"))
+    bed_output = bed_dir /  str(aligned_BAM.name).replace(".bam", "_bed.bed")
 
     print(f"Creating BED-like file from BAM (with MAPQ and avg base quality): {aligned_BAM}")
 
@@ -64,6 +65,7 @@ def aligned_BAM_to_bed(aligned_BAM, out_dir, fasta, make_bigwigs, threads=None):
 
     def split_bed(bed):
         """Splits into aligned and unaligned reads (chrom == '*')."""
+        bed = str(bed)
         aligned = bed.replace(".bed", "_aligned.bed")
         unaligned = bed.replace(".bed", "_unaligned.bed")
         with open(bed, "r") as infile, open(aligned, "w") as aligned_out, open(unaligned, "w") as unaligned_out:

smftools/informatics/archived/helpers/archived/bam_qc.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Iterable, Optional, Tuple, List
+
+def bam_qc(
+    bam_files: Iterable[str | Path],
+    bam_qc_dir: str | Path,
+    threads: Optional[int],
+    modality: str,
+    stats: bool = True,
+    flagstats: bool = True,
+    idxstats: bool = True,
+) -> None:
+    """
+    QC for BAM/CRAMs: stats, flagstat, idxstats.
+    Prefers pysam; falls back to `samtools` if needed.
+    Runs BAMs in parallel (up to `threads`, default serial).
+    """
+    import subprocess
+    import shutil
+
+    # Try to import pysam once
+    try:
+        import pysam
+        HAVE_PYSAM = True
+    except Exception:
+        HAVE_PYSAM = False
+
+    bam_qc_dir = Path(bam_qc_dir)
+    bam_qc_dir.mkdir(parents=True, exist_ok=True)
+
+    bam_files = [Path(b) for b in bam_files]
+
+    def _has_index(p: Path) -> bool:
+        if p.suffix.lower() == ".bam":
+            bai = p.with_suffix(p.suffix + ".bai")
+            bai_alt = Path(str(p) + ".bai")
+            return bai.exists() or bai_alt.exists()
+        if p.suffix.lower() == ".cram":
+            crai = Path(str(p) + ".crai")
+            return crai.exists()
+        return False
+
+    def _ensure_index(p: Path) -> None:
+        if _has_index(p):
+            return
+        if HAVE_PYSAM:
+            # pysam.index supports both BAM & CRAM
+            pysam.index(str(p))
+        else:
+            cmd = ["samtools", "index", str(p)]
+            subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    def _run_one(bam: Path) -> Tuple[Path, List[Tuple[str, int]]]:
+        # outputs + return (file, [(task_name, returncode)])
+        results: List[Tuple[str, int]] = []
+        base = bam.stem  # filename without .bam
+        out_stats = bam_qc_dir / f"{base}_stats.txt"
+        out_flag = bam_qc_dir / f"{base}_flagstat.txt"
+        out_idx  = bam_qc_dir / f"{base}_idxstats.txt"
+
+        # Make sure index exists (samtools stats/flagstat don’t require, idxstats does)
+        try:
+            _ensure_index(bam)
+        except Exception as e:
+            # Still attempt stats/flagstat if requested
+            print(f"[warn] Indexing failed for {bam}: {e}")
+
+        # Choose runner per task
+        def run_stats():
+            if not stats:
+                return
+            if HAVE_PYSAM and hasattr(pysam, "stats"):
+                txt = pysam.stats(str(bam))
+                out_stats.write_text(txt)
+                results.append(("stats(pysam)", 0))
+            else:
+                cmd = ["samtools", "stats", str(bam)]
+                with open(out_stats, "w") as fh:
+                    cp = subprocess.run(cmd, stdout=fh, stderr=subprocess.PIPE)
+                results.append(("stats(samtools)", cp.returncode))
+                if cp.returncode != 0:
+                    raise RuntimeError(cp.stderr.decode(errors="replace"))
+
+        def run_flagstat():
+            if not flagstats:
+                return
+            if HAVE_PYSAM and hasattr(pysam, "flagstat"):
+                txt = pysam.flagstat(str(bam))
+                out_flag.write_text(txt)
+                results.append(("flagstat(pysam)", 0))
+            else:
+                cmd = ["samtools", "flagstat", str(bam)]
+                with open(out_flag, "w") as fh:
+                    cp = subprocess.run(cmd, stdout=fh, stderr=subprocess.PIPE)
+                results.append(("flagstat(samtools)", cp.returncode))
+                if cp.returncode != 0:
+                    raise RuntimeError(cp.stderr.decode(errors="replace"))
+
+        def run_idxstats():
+            if not idxstats:
+                return
+            if HAVE_PYSAM and hasattr(pysam, "idxstats"):
+                txt = pysam.idxstats(str(bam))
+                out_idx.write_text(txt)
+                results.append(("idxstats(pysam)", 0))
+            else:
+                cmd = ["samtools", "idxstats", str(bam)]
+                with open(out_idx, "w") as fh:
+                    cp = subprocess.run(cmd, stdout=fh, stderr=subprocess.PIPE)
+                results.append(("idxstats(samtools)", cp.returncode))
+                if cp.returncode != 0:
+                    raise RuntimeError(cp.stderr.decode(errors="replace"))
+
+        # Sanity: ensure samtools exists if pysam missing
+        if not HAVE_PYSAM:
+            if not shutil.which("samtools"):
+                raise RuntimeError("Neither pysam nor samtools is available in PATH.")
+
+        # Execute tasks (serial per file; parallelized across files)
+        run_stats()
+        run_flagstat()
+        run_idxstats()
+        return bam, results
+
+    # Parallel across BAMs
+    max_workers = int(threads) if threads and int(threads) > 0 else 1
+    futures = []
+    with ThreadPoolExecutor(max_workers=max_workers) as ex:
+        for b in bam_files:
+            futures.append(ex.submit(_run_one, b))
+
+        for fut in as_completed(futures):
+            try:
+                bam, res = fut.result()
+                summary = ", ".join(f"{name}:{rc}" for name, rc in res) or "no-op"
+                print(f"[qc] {bam.name}: {summary}")
+            except Exception as e:
+                print(f"[error] QC failed: {e}")
+
+    # Placeholders to keep your signature stable
+    if modality not in {"conversion", "direct"}:
+        print(f"[warn] Unknown modality '{modality}', continuing.")
+
+    print("QC processing completed.")
+
+# def bam_qc(bam_files, bam_qc_dir, threads, modality, stats=True, flagstats=True, idxstats=True):
+#     """
+#     Performs QC on BAM files by running samtools stats, flagstat, and idxstats.
+    
+#     Parameters:
+#     - bam_files: List of BAM file paths.
+#     - bam_qc_dir: Directory to save QC reports.
+#     - threads: Number threads to use.
+#     - modality: 'conversion' or 'direct' (affects processing mode).
+#     - stats: Run `samtools stats` if True.
+#     - flagstats: Run `samtools flagstat` if True.
+#     - idxstats: Run `samtools idxstats` if True.
+#     """
+#     import os
+#     import subprocess
+    
+#     # Ensure the QC output directory exists
+#     os.makedirs(bam_qc_dir, exist_ok=True)
+
+#     if threads:
+#         threads = str(threads)
+#     else:
+#         pass
+
+#     for bam in bam_files:
+#         bam_name = os.path.basename(bam).replace(".bam", "")  # Extract filename without extension
+
+#         # Run samtools QC commands based on selected options
+#         if stats:
+#             stats_out = os.path.join(bam_qc_dir, f"{bam_name}_stats.txt")
+#             if threads:
+#                 command = ["samtools", "stats", "-@", threads, bam]
+#             else: 
+#                 command = ["samtools", "stats", bam]
+#             print(f"Running: {' '.join(command)} > {stats_out}")
+#             with open(stats_out, "w") as out_file:
+#                 subprocess.run(command, stdout=out_file)
+
+#         if flagstats:
+#             flagstats_out = os.path.join(bam_qc_dir, f"{bam_name}_flagstat.txt")
+#             if threads:
+#                 command = ["samtools", "flagstat", "-@", threads, bam]
+#             else:
+#                 command = ["samtools", "flagstat", bam]
+#             print(f"Running: {' '.join(command)} > {flagstats_out}")
+#             with open(flagstats_out, "w") as out_file:
+#                 subprocess.run(command, stdout=out_file)
+
+#         if idxstats:
+#             idxstats_out = os.path.join(bam_qc_dir, f"{bam_name}_idxstats.txt")
+#             if threads:
+#                 command = ["samtools", "idxstats", "-@", threads, bam]
+#             else:
+#                 command = ["samtools", "idxstats", bam]
+#             print(f"Running: {' '.join(command)} > {idxstats_out}")
+#             with open(idxstats_out, "w") as out_file:
+#                 subprocess.run(command, stdout=out_file)
+
+#         if modality == 'conversion':
+#             pass
+#         elif modality == 'direct':
+#             pass
+
+#     print("QC processing completed.")   

smftools/informatics/archived/helpers/archived/bed_to_bigwig.py

@@ -0,0 +1,90 @@
+from pathlib import Path
+import pybedtools
+import pyBigWig
+
+def bed_to_bigwig(fasta: str, bed: str) -> str:
+    """
+    BED → bedGraph → bigWig
+    Requires:
+      - FASTA must have .fai index present
+    """
+
+    bed = Path(bed)
+    fa = Path(fasta)  # path to .fa
+    parent = bed.parent
+    stem = bed.stem
+    fa_stem = fa.stem
+    fai = parent / f"{fa_stem}.fai"
+
+    bedgraph = parent / f"{stem}.bedgraph"
+    bigwig = parent / f"{stem}.bw"
+
+    # 1) Compute coverage → bedGraph
+    print(f"[pybedtools] generating coverage bedgraph from {bed}")
+    bt = pybedtools.BedTool(str(bed))
+    # bedtools genomecov -bg
+    coverage = bt.genome_coverage(bg=True, genome=str(fai))
+    coverage.saveas(str(bedgraph))
+
+    # 2) Convert bedGraph → BigWig via pyBigWig
+    print(f"[pyBigWig] converting bedgraph → bigwig: {bigwig}")
+
+    # read chrom sizes from the FASTA .fai index
+    chrom_sizes = {}
+    with open(fai) as f:
+        for line in f:
+            fields = line.strip().split("\t")
+            chrom = fields[0]
+            size = int(fields[1])
+            chrom_sizes[chrom] = size
+
+    bw = pyBigWig.open(str(bigwig), "w")
+    bw.addHeader(list(chrom_sizes.items()))
+
+    with open(bedgraph) as f:
+        for line in f:
+            chrom, start, end, coverage = line.strip().split()
+            bw.addEntries(chrom, int(start), ends=int(end), values=float(coverage))
+
+    bw.close()
+
+    print(f"BigWig written: {bigwig}")
+    return str(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)