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

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)

smftools/informatics/archived/helpers/archived/concatenate_fastqs_to_bam.py

@@ -0,0 +1,259 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, List, Any, Tuple, Union, Optional
+import re
+from itertools import zip_longest
+
+import pysam
+from tqdm import tqdm
+
+
+def concatenate_fastqs_to_bam(
+    fastq_files: List[Union[str, Tuple[str, str], Path, Tuple[Path, Path]]],
+    output_bam: Union[str, Path],
+    barcode_tag: str = "BC",
+    barcode_map: Optional[Dict[Union[str, Path], str]] = None,
+    add_read_group: bool = True,
+    rg_sample_field: Optional[str] = None,
+    progress: bool = True,
+    auto_pair: bool = True,
+) -> Dict[str, Any]:
+    """
+    Concatenate FASTQ(s) into an **unaligned** BAM. Supports single-end and paired-end.
+
+    Parameters
+    ----------
+    fastq_files : list[Path|str] or list[(Path|str, Path|str)]
+        Either explicit pairs (R1,R2) or a flat list of FASTQs (auto-paired if auto_pair=True).
+    output_bam : Path|str
+        Output BAM path (parent directory will be created).
+    barcode_tag : str
+        SAM tag used to store barcode on each read (default 'BC').
+    barcode_map : dict or None
+        Optional mapping {path: barcode} to override automatic filename-based barcode extraction.
+    add_read_group : bool
+        If True, add @RG header lines (ID = barcode) and set each read's RG tag.
+    rg_sample_field : str or None
+        If set, include SM=<value> in @RG.
+    progress : bool
+        Show tqdm progress bars.
+    auto_pair : bool
+        Auto-pair R1/R2 based on filename patterns if given a flat list.
+
+    Returns
+    -------
+    dict
+      {'total_reads','per_file','paired_pairs_written','singletons_written','barcodes'}
+    """
+
+    # ---------- helpers (Pathlib-only) ----------
+    def _strip_fastq_ext(p: Path) -> str:
+        """
+        Remove common FASTQ multi-suffixes; return stem-like name.
+        """
+        name = p.name
+        lowers = name.lower()
+        for ext in (".fastq.gz", ".fq.gz", ".fastq.bz2", ".fq.bz2", ".fastq.xz", ".fq.xz", ".fastq", ".fq"):
+            if lowers.endswith(ext):
+                return name[: -len(ext)]
+        return p.stem  # fallback: remove last suffix only
+
+    def _extract_barcode_from_filename(p: Path) -> str:
+        stem = _strip_fastq_ext(p)
+        if "_" in stem:
+            token = stem.split("_")[-1]
+            if token:
+                return token
+        return stem
+
+    def _classify_read_token(stem: str) -> Tuple[Optional[str], Optional[int]]:
+        # return (prefix, readnum) if matches; else (None, None)
+        patterns = [
+            r"(?i)(.*?)[._-]r?([12])$",        # prefix_R1 / prefix.r2 / prefix-1
+            r"(?i)(.*?)[._-]read[_-]?([12])$", # prefix_read1
+        ]
+        for pat in patterns:
+            m = re.match(pat, stem)
+            if m:
+                return m.group(1), int(m.group(2))
+        return None, None
+
+    def _pair_by_filename(paths: List[Path]) -> Tuple[List[Tuple[Path, Path]], List[Path]]:
+        pref_map: Dict[str, Dict[int, Path]] = {}
+        unpaired: List[Path] = []
+        for pth in paths:
+            stem = _strip_fastq_ext(pth)
+            pref, num = _classify_read_token(stem)
+            if pref is None:
+                unpaired.append(pth)
+            else:
+                entry = pref_map.setdefault(pref, {})
+                entry[num] = pth
+        pairs: List[Tuple[Path, Path]] = []
+        leftovers: List[Path] = []
+        for d in pref_map.values():
+            if 1 in d and 2 in d:
+                pairs.append((d[1], d[2]))
+            else:
+                leftovers.extend(d.values())
+        leftovers.extend(unpaired)
+        return pairs, leftovers
+
+    def _fastq_iter(p: Path):
+        # pysam.FastxFile handles compressed extensions transparently
+        with pysam.FastxFile(str(p)) as fx:
+            for rec in fx:
+                yield rec  # rec.name, rec.sequence, rec.quality
+
+    def _make_unaligned_segment(
+        name: str,
+        seq: str,
+        qual: Optional[str],
+        bc: str,
+        read1: bool,
+        read2: bool,
+    ) -> pysam.AlignedSegment:
+        a = pysam.AlignedSegment()
+        a.query_name = name
+        a.query_sequence = seq
+        if qual is not None:
+            a.query_qualities = pysam.qualitystring_to_array(qual)
+        a.is_unmapped = True
+        a.is_paired = read1 or read2
+        a.is_read1 = read1
+        a.is_read2 = read2
+        a.mate_is_unmapped = a.is_paired
+        a.reference_id = -1
+        a.reference_start = -1
+        a.next_reference_id = -1
+        a.next_reference_start = -1
+        a.template_length = 0
+        a.set_tag(barcode_tag, str(bc), value_type="Z")
+        if add_read_group:
+            a.set_tag("RG", str(bc), value_type="Z")
+        return a
+
+    # ---------- normalize inputs to Path ----------
+    def _to_path_pair(x) -> Tuple[Path, Path]:
+        a, b = x
+        return Path(a), Path(b)
+
+    explicit_pairs: List[Tuple[Path, Path]] = []
+    singles: List[Path] = []
+
+    if not isinstance(fastq_files, (list, tuple)):
+        raise ValueError("fastq_files must be a list of paths or list of (R1,R2) tuples.")
+
+    if all(isinstance(x, (list, tuple)) and len(x) == 2 for x in fastq_files):
+        explicit_pairs = [_to_path_pair(x) for x in fastq_files]
+    else:
+        flat_paths = [Path(x) for x in fastq_files if x is not None]
+        if auto_pair:
+            explicit_pairs, leftovers = _pair_by_filename(flat_paths)
+            singles = leftovers
+        else:
+            singles = flat_paths
+
+    output_bam = Path(output_bam)
+    output_bam.parent.mkdir(parents=True, exist_ok=True)
+
+    # ---------- barcodes ----------
+    barcode_map = {Path(k): v for k, v in (barcode_map or {}).items()}
+    per_path_barcode: Dict[Path, str] = {}
+    barcodes_in_order: List[str] = []
+
+    for r1, r2 in explicit_pairs:
+        bc = barcode_map.get(r1) or barcode_map.get(r2) or _extract_barcode_from_filename(r1)
+        per_path_barcode[r1] = bc
+        per_path_barcode[r2] = bc
+        if bc not in barcodes_in_order:
+            barcodes_in_order.append(bc)
+    for pth in singles:
+        bc = barcode_map.get(pth) or _extract_barcode_from_filename(pth)
+        per_path_barcode[pth] = bc
+        if bc not in barcodes_in_order:
+            barcodes_in_order.append(bc)
+
+    # ---------- BAM header ----------
+    header = {"HD": {"VN": "1.6", "SO": "unknown"}, "SQ": []}
+    if add_read_group:
+        header["RG"] = [{"ID": bc, **({"SM": rg_sample_field} if rg_sample_field else {})} for bc in barcodes_in_order]
+    header.setdefault("PG", []).append(
+        {"ID": "concat-fastq", "PN": "concatenate_fastqs_to_bam", "VN": "1"}
+    )
+
+    # ---------- counters ----------
+    per_file_counts: Dict[Path, int] = {}
+    total_written = 0
+    paired_pairs_written = 0
+    singletons_written = 0
+
+    # ---------- write BAM ----------
+    with pysam.AlignmentFile(str(output_bam), "wb", header=header) as bam_out:
+        # Paired
+        it_pairs = explicit_pairs
+        if progress and it_pairs:
+            it_pairs = tqdm(it_pairs, desc="Paired FASTQ→BAM")
+        for r1_path, r2_path in it_pairs:
+            if not (r1_path.exists() and r2_path.exists()):
+                raise FileNotFoundError(f"Paired file missing: {r1_path} or {r2_path}")
+            bc = per_path_barcode.get(r1_path) or per_path_barcode.get(r2_path) or "barcode"
+
+            it1 = _fastq_iter(r1_path)
+            it2 = _fastq_iter(r2_path)
+
+            for rec1, rec2 in zip_longest(it1, it2, fillvalue=None):
+                def _clean(n: Optional[str]) -> Optional[str]:
+                    if n is None:
+                        return None
+                    return re.sub(r"(?:/1$|/2$|\s[12]$)", "", n)
+
+                name = (
+                    _clean(getattr(rec1, "name", None))
+                    or _clean(getattr(rec2, "name", None))
+                    or getattr(rec1, "name", None)
+                    or getattr(rec2, "name", None)
+                )
+
+                if rec1 is not None:
+                    a1 = _make_unaligned_segment(name, rec1.sequence, rec1.quality, bc, read1=True, read2=False)
+                    bam_out.write(a1)
+                    per_file_counts[r1_path] = per_file_counts.get(r1_path, 0) + 1
+                    total_written += 1
+                if rec2 is not None:
+                    a2 = _make_unaligned_segment(name, rec2.sequence, rec2.quality, bc, read1=False, read2=True)
+                    bam_out.write(a2)
+                    per_file_counts[r2_path] = per_file_counts.get(r2_path, 0) + 1
+                    total_written += 1
+
+                if rec1 is not None and rec2 is not None:
+                    paired_pairs_written += 1
+                else:
+                    if rec1 is not None:
+                        singletons_written += 1
+                    if rec2 is not None:
+                        singletons_written += 1
+
+        # Singles
+        it_singles = singles
+        if progress and it_singles:
+            it_singles = tqdm(it_singles, desc="Single FASTQ→BAM")
+        for pth in it_singles:
+            if not pth.exists():
+                raise FileNotFoundError(pth)
+            bc = per_path_barcode.get(pth, "barcode")
+            for rec in _fastq_iter(pth):
+                a = _make_unaligned_segment(rec.name, rec.sequence, rec.quality, bc, read1=False, read2=False)
+                bam_out.write(a)
+                per_file_counts[pth] = per_file_counts.get(pth, 0) + 1
+                total_written += 1
+                singletons_written += 1
+
+    return {
+        "total_reads": total_written,
+        "per_file": {str(k): v for k, v in per_file_counts.items()},
+        "paired_pairs_written": paired_pairs_written,
+        "singletons_written": singletons_written,
+        "barcodes": barcodes_in_order,
+    }

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

@@ -14,7 +14,7 @@ def count_aligned_reads(bam_file):
        record_counts (dict): A dictionary keyed by reference record instance that points toa tuple containing the total reads mapped to the record and the fraction of mapped reads which map to the record.
 
     """
-    from .. import readwrite
+    from ... import readwrite
     import pysam
     from tqdm import tqdm
     from collections import defaultdict
@@ -25,7 +25,7 @@ def count_aligned_reads(bam_file):
     # Make a dictionary, keyed by the reference_name of reference chromosome that points to an integer number of read counts mapped to the chromosome, as well as the proportion of mapped reads in that chromosome
     record_counts = defaultdict(int)
 
-    with pysam.AlignmentFile(bam_file, "rb") as bam:
+    with pysam.AlignmentFile(str(bam_file), "rb") as bam:
         total_reads = bam.mapped + bam.unmapped
         # Iterate over reads to get the total mapped read counts and the reads that map to each reference
         for read in tqdm(bam, desc='Counting aligned reads in BAM', total=total_reads):

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

@@ -18,13 +18,12 @@ def demux_and_index_BAM(aligned_sorted_BAM, split_dir, bam_suffix, barcode_kit,
         bam_files (list): List of split BAM file path strings
             Splits an input BAM file on barcode value and makes a BAM index file.
     """
-    from .. import readwrite
+    from ...readwrite import make_dirs
     import os
     import subprocess
     import glob
-    from .make_dirs import make_dirs
     
-    input_bam = aligned_sorted_BAM + bam_suffix
+    input_bam = aligned_sorted_BAM.with_suffix(bam_suffix)
     command = ["dorado", "demux", "--kit-name", barcode_kit]
     if barcode_both_ends:
         command.append("--barcode-both-ends")
@@ -34,17 +33,16 @@ def demux_and_index_BAM(aligned_sorted_BAM, split_dir, bam_suffix, barcode_kit,
         command += ["-t", str(threads)]
     else:
         pass
-    command += ["--emit-summary", "--sort-bam", "--output-dir", split_dir]
-    command.append(input_bam)
+    command += ["--emit-summary", "--sort-bam", "--output-dir", str(split_dir)]
+    command.append(str(input_bam))
     command_string = ' '.join(command)
     print(f"Running: {command_string}")
     subprocess.run(command)
 
-    # Make a BAM index file for the BAMs in that directory
-    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()
+    bam_files = sorted(
+        p for p in split_dir.glob(f"*{bam_suffix}")
+        if p.is_file() and p.suffix == bam_suffix and "unclassified" not in p.name
+    )
 
     if not bam_files:
         raise FileNotFoundError(f"No BAM files found in {split_dir} with suffix {bam_suffix}")

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

@@ -27,7 +27,7 @@ def extract_base_identities(bam_file, chromosome, positions, max_reference_lengt
     mismatch_counts_per_read = defaultdict(lambda: defaultdict(Counter))
 
     #print(f"{timestamp} Reading reads from {chromosome} BAM file: {bam_file}")
-    with pysam.AlignmentFile(bam_file, "rb") as bam:
+    with pysam.AlignmentFile(str(bam_file), "rb") as bam:
         total_reads = bam.mapped
         ref_seq = sequence.upper()
         for read in bam.fetch(chromosome):