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

smftools/informatics/helpers/binarize_converted_base_identities.py

@@ -0,0 +1,172 @@
+def binarize_converted_base_identities(base_identities, strand, modification_type, bam, device='cpu', deaminase_footprinting=False, mismatch_trend_per_read={}, on_missing="nan"):
+    """
+    Efficiently binarizes conversion SMF data within a sequence string using NumPy arrays.
+
+    Parameters:
+        base_identities (dict): A dictionary returned by extract_base_identities. Keyed by read name. Points to a list of base identities.
+        strand (str): A string indicating which strand was converted in the experiment (options are 'top' and 'bottom').
+        modification_type (str): A string indicating the modification type of interest (options are '5mC' and '6mA').
+        bam (str): The bam file path
+        deaminase_footprinting (bool): Whether direct deaminase footprinting chemistry was used.
+        mismatch_trend_per_read (dict): For deaminase footprinting, indicates the type of conversion relative to the top strand reference for each read. (C->T or G->A if bottom strand was converted)
+        on_missing (str): Error handling if a read is missing
+        
+    Returns:
+        dict: A dictionary where 1 represents a methylated site, 0 represents an unmethylated site, and NaN represents a site without methylation info.
+        If deaminase_footprinting, 1 represents deaminated sites, while 0 represents non-deaminated sites.
+    """
+    import numpy as np
+
+    if mismatch_trend_per_read is None:
+        mismatch_trend_per_read = {}
+
+    # Fast path
+    if modification_type == "unconverted" and not deaminase_footprinting:
+        return {k: np.full(len(v), np.nan, dtype=np.float32) for k, v in base_identities.items()}
+
+    out = {}
+
+    if deaminase_footprinting:
+        valid_trends = {"C->T", "G->A"}
+
+        for read_id, bases in base_identities.items():
+            trend_raw = mismatch_trend_per_read.get(read_id, None)
+            if trend_raw is None:
+                if on_missing == "error":
+                    raise KeyError(f"Missing mismatch trend for read '{read_id}'")
+                out[read_id] = np.full(len(bases), np.nan, dtype=np.float32)
+                continue
+
+            trend = trend_raw.replace(" ", "").upper()
+            if trend not in valid_trends:
+                if on_missing == "error":
+                    raise KeyError(
+                        f"Invalid mismatch trend '{trend_raw}' for read '{read_id}'. "
+                        f"Expected one of {sorted(valid_trends)}"
+                    )
+                out[read_id] = np.full(len(bases), np.nan, dtype=np.float32)
+                continue
+
+            arr = np.asarray(bases, dtype="<U1")
+            res = np.full(arr.shape, np.nan, dtype=np.float32)
+
+            if trend == "C->T":
+                # C (unconverted) -> 0, T (converted) -> 1
+                res[arr == "C"] = 0.0
+                res[arr == "T"] = 1.0
+            else:  # "G->A"
+                res[arr == "G"] = 0.0
+                res[arr == "A"] = 1.0
+
+            out[read_id] = res
+
+        return out
+
+    # Non-deaminase mapping (bisulfite-style for 5mC; 6mA mapping is protocol dependent)
+    bin_maps = {
+        ("top", "5mC"):    {"C": 1.0, "T": 0.0},
+        ("bottom", "5mC"): {"G": 1.0, "A": 0.0},
+        ("top", "6mA"):    {"A": 1.0, "G": 0.0},
+        ("bottom", "6mA"): {"T": 1.0, "C": 0.0},
+    }
+    key = (strand, modification_type)
+    if key not in bin_maps:
+        raise ValueError(f"Invalid combination of strand='{strand}' and modification_type='{modification_type}'")
+
+    base_map = bin_maps[key]
+
+    for read_id, bases in base_identities.items():
+        arr = np.asarray(bases, dtype="<U1")
+        res = np.full(arr.shape, np.nan, dtype=np.float32)
+        # mask-assign; unknown characters (N, -, etc.) remain NaN
+        for b, v in base_map.items():
+            res[arr == b] = v
+        out[read_id] = res
+
+    return out
+
+    # if mismatch_trend_per_read is None:
+    #     mismatch_trend_per_read = {}
+
+    # # If the modification type is 'unconverted', return NaN for all positions if the deaminase_footprinting strategy is not being used.
+    # if modification_type == "unconverted" and not deaminase_footprinting:
+    #     #print(f"Skipping binarization for unconverted {strand} reads on bam: {bam}.")
+    #     return {key: np.full(len(bases), np.nan) for key, bases in base_identities.items()}
+
+    # # Define mappings for binarization based on strand and modification type
+    # if deaminase_footprinting:
+    #     binarization_maps = {
+    #         ('C->T'): {'C': 0, 'T': 1},
+    #         ('G->A'): {'G': 0, 'A': 1},
+    #     }
+
+    #     binarized_base_identities = {}
+    #     for key, bases in base_identities.items():
+    #         arr = np.array(bases, dtype='<U1')
+    #         # Fetch the appropriate mapping
+    #         conversion_type = mismatch_trend_per_read[key]
+    #         base_map = binarization_maps.get(conversion_type, None)
+    #         binarized = np.vectorize(lambda x: base_map.get(x, np.nan))(arr)  # Apply mapping with fallback to NaN
+    #         binarized_base_identities[key] = binarized
+
+    #     return binarized_base_identities
+    
+    # else:
+    #     binarization_maps = {
+    #         ('top', '5mC'): {'C': 1, 'T': 0},
+    #         ('top', '6mA'): {'A': 1, 'G': 0},
+    #         ('bottom', '5mC'): {'G': 1, 'A': 0},
+    #         ('bottom', '6mA'): {'T': 1, 'C': 0}
+    #     }
+
+    #     if (strand, modification_type) not in binarization_maps:
+    #         raise ValueError(f"Invalid combination of strand='{strand}' and modification_type='{modification_type}'")
+
+    #     # Fetch the appropriate mapping
+    #     base_map = binarization_maps[(strand, modification_type)]
+
+    #     binarized_base_identities = {}
+    #     for key, bases in base_identities.items():
+    #         arr = np.array(bases, dtype='<U1')
+    #         binarized = np.vectorize(lambda x: base_map.get(x, np.nan))(arr)  # Apply mapping with fallback to NaN
+    #         binarized_base_identities[key] = binarized
+
+    #     return binarized_base_identities
+    # import torch
+
+    # # If the modification type is 'unconverted', return NaN for all positions
+    # if modification_type == "unconverted":
+    #     print(f"Skipping binarization for unconverted {strand} reads on bam: {bam}.")
+    #     return {key: torch.full((len(bases),), float('nan'), device=device) for key, bases in base_identities.items()}
+
+    # # Define mappings for binarization based on strand and modification type
+    # binarization_maps = {
+    #     ('top', '5mC'): {'C': 1, 'T': 0},
+    #     ('top', '6mA'): {'A': 1, 'G': 0},
+    #     ('bottom', '5mC'): {'G': 1, 'A': 0},
+    #     ('bottom', '6mA'): {'T': 1, 'C': 0}
+    # }
+
+    # if (strand, modification_type) not in binarization_maps:
+    #     raise ValueError(f"Invalid combination of strand='{strand}' and modification_type='{modification_type}'")
+
+    # # Fetch the appropriate mapping
+    # base_map = binarization_maps[(strand, modification_type)]
+    
+    # # Convert mapping to tensor
+    # base_keys = list(base_map.keys())
+    # base_values = torch.tensor(list(base_map.values()), dtype=torch.float32, device=device)
+
+    # # Create a lookup dictionary (ASCII-based for fast mapping)
+    # lookup_table = torch.full((256,), float('nan'), dtype=torch.float32, device=device)
+    # for k, v in zip(base_keys, base_values):
+    #     lookup_table[ord(k)] = v
+
+    # # Process reads
+    # binarized_base_identities = {}
+    # for key, bases in base_identities.items():
+    #     bases_tensor = torch.tensor([ord(c) for c in bases], dtype=torch.uint8, device=device)  # Convert chars to ASCII
+    #     binarized = lookup_table[bases_tensor]  # Efficient lookup
+    #     binarized_base_identities[key] = binarized
+
+    # return binarized_base_identities

smftools/informatics/helpers/canoncall.py

@@ -0,0 +1,34 @@
+## canoncall
+
+# Conversion SMF specific
+def canoncall(model_dir, model, pod5_dir, barcode_kit, bam, bam_suffix, barcode_both_ends=True, trim=False, device='auto'):
+    """
+    Wrapper function for dorado canonical base calling.
+
+    Parameters:
+        model_dir (str): a string representing the file path to the dorado basecalling model directory.
+        model (str): a string representing the the dorado basecalling model.
+        pod5_dir (str): a string representing the file path to the experiment directory containing the POD5 files.
+        barcode_kit (str): A string reppresenting the barcoding kit used in the experiment.
+        bam (str): File path to the BAM file to output.
+        bam_suffix (str): The suffix to use for the BAM file.
+        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): The device to use. 'auto' is default, which can detect device to use. Can also specify metal, cpu, cuda.
+    
+    Returns:
+        None
+            Outputs a BAM file holding the canonical base calls output by the dorado basecaller.
+    """
+    import subprocess
+    output = bam + bam_suffix
+    command = ["dorado", "basecaller", "--models-directory", model_dir, "--kit-name", barcode_kit, "--device", device, "--batchsize", "0"]
+    if barcode_both_ends:
+        command.append("--barcode-both-ends")
+    if not trim:
+        command.append("--no-trim")
+    command += [model, pod5_dir]
+    command_string = " ".join(command)
+    print(f"Running {command_string}\n to generate {output}")
+    with open(output, "w") as outfile:
+        subprocess.run(command, stdout=outfile)

smftools/informatics/helpers/complement_base_list.py

@@ -0,0 +1,21 @@
+# complement_base_list
+
+def complement_base_list(sequence):
+    """
+    Takes a list of DNA base identities and returns their complement.
+
+    Parameters:
+        sequence (list): A list of DNA bases (e.g., ['A', 'C', 'G', 'T']).
+
+    Returns:
+        complement (list): A list of complementary DNA bases.
+    """
+    complement_mapping = {
+        'A': 'T',
+        'T': 'A',
+        'C': 'G',
+        'G': 'C',
+        'N': 'N'  # Handling ambiguous bases like 'N'
+    }
+
+    return [complement_mapping[base] for base in sequence]

smftools/informatics/helpers/concatenate_fastqs_to_bam.py

@@ -0,0 +1,378 @@
+# concatenate_fastqs_to_bam
+
+def concatenate_fastqs_to_bam(
+    fastq_files,
+    output_bam,
+    barcode_tag='BC',
+    gzip_suffixes=('.gz',),
+    barcode_map=None,
+    add_read_group=True,
+    rg_sample_field=None,
+    progress=True,
+    auto_pair=True,
+):
+    """
+    Concatenate FASTQ(s) into an unaligned BAM. Supports single-end and paired-end (auto-detect or explicit).
+
+    Parameters
+    ----------
+    fastq_files : list[str] or list[(str,str)]
+        If list of tuples: each tuple is (R1_path, R2_path).
+        If list of strings and auto_pair=True: the function will attempt to automatically pair files.
+    output_bam : str
+        Path to output BAM (will be overwritten).
+    barcode_tag : str
+        SAM tag used for barcode (default 'BC').
+    gzip_suffixes : tuple
+        Compressed suffixes to consider (default ('.gz',)).
+    barcode_map : dict or None
+        Optional mapping {path: barcode} to override automatic extraction.
+    add_read_group : bool
+        If True, add RG entries and set RG tag per-read (ID = barcode).
+    rg_sample_field : str or None
+        If set, includes SM field in RG header entries.
+    progress : bool
+        Show tqdm progress bar.
+    auto_pair : bool
+        If True and `fastq_files` is a list of strings, attempt to auto-pair R1/R2 by filename patterns.
+
+    Returns
+    -------
+    dict
+        Summary: {'total_reads', 'per_file_counts', 'paired_count', 'unpaired_count', 'barcodes'}
+    """
+    import os
+    import re
+    import gzip
+    from itertools import zip_longest
+    from Bio import SeqIO
+    import pysam
+    from tqdm import tqdm
+
+    # ---------- helpers ----------
+    def _is_gz(path):
+        pl = path.lower()
+        return any(pl.endswith(suf) for suf in gzip_suffixes)
+
+    def _strip_fastq_ext(basn):
+        # remove .fastq.gz .fq.gz .fastq .fq
+        for ext in ('.fastq.gz', '.fq.gz', '.fastq', '.fq'):
+            if basn.lower().endswith(ext):
+                return basn[:-len(ext)]
+        # fallback remove last suffix
+        return os.path.splitext(basn)[0]
+
+    def _extract_barcode_from_filename(path):
+        # heuristic: barcode is last underscore-separated token in filename (before ext)
+        stem = _strip_fastq_ext(os.path.basename(path))
+        if '_' in stem:
+            token = stem.split('_')[-1]
+            if token:
+                return token
+        # fallback to whole stem
+        return stem
+
+    # pairing heuristics: try to identify suffix that marks read number
+    def _classify_read_token(stem):
+        # returns (prefix, readnum) if matches, else (None, None)
+        patterns = [
+            r'(?i)(.*?)[._-]r?([12])$',  # prefix_R1 or prefix.r1 or prefix-1
+            r'(?i)(.*?)[._-]read[_-]?([12])$',
+            r'(?i)(.*?)[/_]([12])$',      # sometimes /1 is used (rare in filenames)
+        ]
+        for pat in patterns:
+            m = re.match(pat, stem)
+            if m:
+                prefix = m.group(1)
+                num = m.group(2)
+                return prefix, int(num)
+        return None, None
+
+    def pair_by_filename(paths):
+        # paths: list of strings
+        map_pref = {}  # prefix -> {1: path, 2: path, 'orphans': [..]}
+        unpaired = []
+        for p in paths:
+            name = os.path.basename(p)
+            stem = _strip_fastq_ext(name)
+            pref, num = _classify_read_token(stem)
+            if pref is not None:
+                entry = map_pref.setdefault(pref, {})
+                entry[num] = p
+            else:
+                # try fallback: split by last underscore or dot and check last token is 1/2 or R1/R2
+                toks = re.split(r'[_\.]', stem)
+                if toks and toks[-1] in ('1', '2', 'R1', 'R2', 'r1', 'r2'):
+                    last = toks[-1]
+                    basepref = "_".join(toks[:-1]) if len(toks) > 1 else toks[0]
+                    num = 1 if last.endswith('1') else 2
+                    entry = map_pref.setdefault(basepref, {})
+                    entry[num] = p
+                else:
+                    unpaired.append(p)
+        pairs = []
+        leftovers = []
+        for k, d in map_pref.items():
+            if 1 in d and 2 in d:
+                pairs.append((d[1], d[2]))
+            else:
+                # put whoever exists into leftovers
+                leftovers.extend([v for kk, v in d.items()])
+        # append also unpaired
+        leftovers.extend(unpaired)
+        return pairs, leftovers
+
+    # ---------- normalize input ----------
+    explicit_pairs = []
+    singles = []
+    if not isinstance(fastq_files, (list, tuple)):
+        raise ValueError("fastq_files must be a list of paths or list of (R1,R2) tuples.")
+
+    # mixture: if user supplied tuples -> treat as explicit pairs
+    if all(isinstance(x, (list, tuple)) and len(x) == 2 for x in fastq_files):
+        explicit_pairs = [(str(a), str(b)) for a, b in fastq_files]
+    else:
+        # flatten and coerce to strings, ignore None
+        paths = [str(x) for x in fastq_files if x is not None]
+        if auto_pair:
+            explicit_pairs, leftovers = pair_by_filename(paths)
+            singles = leftovers
+        else:
+            singles = paths
+
+    # Build barcode map and ordered barcodes
+    barcode_map = barcode_map or {}
+    per_path_barcode = {}
+    barcodes_in_order = []
+
+    # pairs: assign barcode per pair from either provided barcode_map for first file or from filenames
+    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 p in singles:
+        bc = barcode_map.get(p) or _extract_barcode_from_filename(p)
+        per_path_barcode[p] = bc
+        if bc not in barcodes_in_order:
+            barcodes_in_order.append(bc)
+
+    # prepare BAM header
+    header = {"HD": {"VN": "1.0"}, "SQ": []}
+    if add_read_group:
+        rg_list = []
+        for bc in barcodes_in_order:
+            rg = {"ID": bc}
+            if rg_sample_field:
+                rg["SM"] = rg_sample_field
+            rg_list.append(rg)
+        header["RG"] = rg_list
+
+    # ---------- write BAM ----------
+    per_file_counts = {}
+    total_written = 0
+    paired_count = 0
+    unpaired_count = 0
+
+    def _open_fh(path):
+        return gzip.open(path, "rt") if _is_gz(path) else open(path, "rt")
+
+    with pysam.AlignmentFile(output_bam, "wb", header=header) as bam_out:
+        # process paired files first
+        seq_iter = list(explicit_pairs)  # list of (r1,r2)
+        if progress:
+            seq_iter = tqdm(seq_iter, desc="Paired FASTQ->BAM")
+        for r1_path, r2_path in seq_iter:
+            if not (os.path.exists(r1_path) and os.path.exists(r2_path)):
+                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"
+            # open both and iterate in parallel
+            with _open_fh(r1_path) as fh1, _open_fh(r2_path) as fh2:
+                it1 = SeqIO.parse(fh1, "fastq")
+                it2 = SeqIO.parse(fh2, "fastq")
+                # iterate in lockstep; if one shorter we still write remaining as unpaired (zip_longest)
+                for rec1, rec2 in zip_longest(it1, it2, fillvalue=None):
+                    # determine a common read name
+                    if rec1 is not None:
+                        id1 = rec1.id
+                    else:
+                        id1 = None
+                    if rec2 is not None:
+                        id2 = rec2.id
+                    else:
+                        id2 = None
+                    # try to derive a common name (strip /1 or /2 if present)
+                    def _strip_end_id(s):
+                        if s is None:
+                            return None
+                        return re.sub(r'(?:/1$|/2$|\s[12]$)', '', s)
+                    common_name = _strip_end_id(id1) or _strip_end_id(id2) or (id1 or id2)
+
+                    # create AlignedSegment for read1
+                    if rec1 is not None:
+                        a1 = pysam.AlignedSegment()
+                        a1.query_name = common_name
+                        a1.query_sequence = str(rec1.seq)
+                        a1.is_paired = True
+                        a1.is_read1 = True
+                        a1.is_read2 = False
+                        a1.is_unmapped = True
+                        a1.mate_is_unmapped = True
+                        # reference fields for unmapped
+                        a1.reference_id = -1
+                        a1.reference_start = -1
+                        a1.next_reference_id = -1
+                        a1.next_reference_start = -1
+                        a1.template_length = 0
+                        # qualities
+                        if "phred_quality" in rec1.letter_annotations:
+                            try:
+                                a1.query_qualities = [int(x) for x in rec1.letter_annotations["phred_quality"]]
+                            except Exception:
+                                a1.query_qualities = None
+                        # tags
+                        a1.set_tag(barcode_tag, str(bc), value_type='Z')
+                        if add_read_group:
+                            a1.set_tag("RG", str(bc), value_type='Z')
+                        bam_out.write(a1)
+                        per_file_counts.setdefault(r1_path, 0)
+                        per_file_counts[r1_path] += 1
+                        total_written += 1
+                    # create AlignedSegment for read2
+                    if rec2 is not None:
+                        a2 = pysam.AlignedSegment()
+                        a2.query_name = common_name
+                        a2.query_sequence = str(rec2.seq)
+                        a2.is_paired = True
+                        a2.is_read1 = False
+                        a2.is_read2 = True
+                        a2.is_unmapped = True
+                        a2.mate_is_unmapped = True
+                        a2.reference_id = -1
+                        a2.reference_start = -1
+                        a2.next_reference_id = -1
+                        a2.next_reference_start = -1
+                        a2.template_length = 0
+                        if "phred_quality" in rec2.letter_annotations:
+                            try:
+                                a2.query_qualities = [int(x) for x in rec2.letter_annotations["phred_quality"]]
+                            except Exception:
+                                a2.query_qualities = None
+                        a2.set_tag(barcode_tag, str(bc), value_type='Z')
+                        if add_read_group:
+                            a2.set_tag("RG", str(bc), value_type='Z')
+                        bam_out.write(a2)
+                        per_file_counts.setdefault(r2_path, 0)
+                        per_file_counts[r2_path] += 1
+                        total_written += 1
+                    # count paired/unpaired bookkeeping
+                    if rec1 is not None and rec2 is not None:
+                        paired_count += 1
+                    else:
+                        # one side missing -> counted as unpaired for whichever exists
+                        if rec1 is not None:
+                            unpaired_count += 1
+                        if rec2 is not None:
+                            unpaired_count += 1
+
+        # process singletons
+        single_iter = list(singles)
+        if progress:
+            single_iter = tqdm(single_iter, desc="Single FASTQ->BAM")
+        for p in single_iter:
+            if not os.path.exists(p):
+                raise FileNotFoundError(p)
+            bc = per_path_barcode.get(p, "barcode")
+            with _open_fh(p) as fh:
+                for rec in SeqIO.parse(fh, "fastq"):
+                    a = pysam.AlignedSegment()
+                    a.query_name = rec.id
+                    a.query_sequence = str(rec.seq)
+                    a.is_paired = False
+                    a.is_read1 = False
+                    a.is_read2 = False
+                    a.is_unmapped = True
+                    a.mate_is_unmapped = True
+                    a.reference_id = -1
+                    a.reference_start = -1
+                    a.next_reference_id = -1
+                    a.next_reference_start = -1
+                    a.template_length = 0
+                    if "phred_quality" in rec.letter_annotations:
+                        try:
+                            a.query_qualities = [int(x) for x in rec.letter_annotations["phred_quality"]]
+                        except Exception:
+                            a.query_qualities = None
+                    a.set_tag(barcode_tag, str(bc), value_type='Z')
+                    if add_read_group:
+                        a.set_tag("RG", str(bc), value_type='Z')
+                    bam_out.write(a)
+                    per_file_counts.setdefault(p, 0)
+                    per_file_counts[p] += 1
+                    total_written += 1
+                    unpaired_count += 1
+
+    summary = {
+        "total_reads": total_written,
+        "per_file": per_file_counts,
+        "paired_pairs_written": paired_count,
+        "singletons_written": unpaired_count,
+        "barcodes": barcodes_in_order
+    }
+    return summary
+
+
+# def concatenate_fastqs_to_bam(fastq_files, output_bam, barcode_tag='BC', gzip_suffix='.gz'):
+#     """
+#     Concatenate multiple demultiplexed FASTQ (.fastq or .fq) files into an unaligned BAM and add the FASTQ barcode suffix to the BC tag.
+
+#     Parameters:
+#         fastq_files (list): List of paths to demultiplexed FASTQ files.
+#         output_bam (str): Path to the output BAM file.
+#         barcode_tag (str): The SAM tag for storing the barcode (default: 'BC').
+#         gzip_suffix (str): Suffix to use for input gzip files (Defaul: '.gz')
+
+#     Returns:
+#         None
+#     """
+#     import os
+#     import pysam
+#     import gzip
+#     from Bio import SeqIO
+#     from tqdm import tqdm
+
+#     n_fastqs = len(fastq_files)
+
+#     with pysam.AlignmentFile(output_bam, "wb", header={"HD": {"VN": "1.0"}, "SQ": []}) as bam_out:
+#         for fastq_file in tqdm(fastq_files, desc="Processing FASTQ files"):
+#             # Extract barcode from the FASTQ filename (handles .fq, .fastq, .fq.gz, and .fastq.gz extensions)
+#             base_name = os.path.basename(fastq_file)
+#             if n_fastqs > 1:
+#                 if base_name.endswith('.fastq.gz'):
+#                     barcode = base_name.split('_')[-1].replace(f'.fastq{gzip_suffix}', '')
+#                 elif base_name.endswith('.fq.gz'):
+#                     barcode = base_name.split('_')[-1].replace(f'.fq{gzip_suffix}', '')
+#                 elif base_name.endswith('.fastq'):
+#                     barcode = base_name.split('_')[-1].replace('.fastq', '')
+#                 elif base_name.endswith('.fq'):
+#                     barcode = base_name.split('_')[-1].replace('.fq', '')
+#                 else:
+#                     raise ValueError(f"Unexpected file extension for {fastq_file}. Only .fq, .fastq, .fq{gzip_suffix}, and .fastq{gzip_suffix} are supported.")
+#             else:
+#                 barcode = 'barcode0'
+
+#             # Read the FASTQ file (handle gzipped and non-gzipped files)
+#             open_func = gzip.open if fastq_file.endswith(gzip_suffix) else open
+#             with open_func(fastq_file, 'rt') as fq_in:
+#                 for record in SeqIO.parse(fq_in, 'fastq'):
+#                     # Create an unaligned BAM entry for each FASTQ record
+#                     aln = pysam.AlignedSegment()
+#                     aln.query_name = record.id
+#                     aln.query_sequence = str(record.seq)
+#                     aln.flag = 4  # Unmapped
+#                     aln.query_qualities = pysam.qualitystring_to_array(record.letter_annotations["phred_quality"])
+#                     # Add the barcode to the BC tag
+#                     aln.set_tag(barcode_tag, barcode)
+#                     # Write to BAM file
+#                     bam_out.write(aln)