split3c 0.0.1__py3-none-any.whl

split3c/nssite/split.py

@@ -0,0 +1,849 @@
+import logging
+import os
+import signal
+import sys
+import time
+from multiprocessing import Queue
+
+from .auxiliary import check_data, handle_write_cmd, partitionning
+from .bam import (
+    get_bam_header_single,
+    get_bam_headers,
+    read_bam_interleaved,
+    read_bam_pair,
+    write_bam_interleaved_from_sam,
+    write_bam_pair_from_sam,
+)
+from .fastq import write_fastq_pair
+from .processmanager import ProcessManager
+
+logger = logging.getLogger(__name__)
+
+
+def build_cigar_tuple(cigar):
+    """
+    Parse CIGAR string into tuples of operations and lengths.
+
+    Examples
+    --------
+    >>> build_cigar_tuple("10M1I5M2D3S")
+    [['M', 'I', 'M', 'D', 'S'], [10, 1, 5, 2, 3]]
+    >>> build_cigar_tuple("5S95M")
+    [['S', 'M'], [5, 95]]
+    >>> build_cigar_tuple("100M")
+    [['M'], [100]]
+    >>> build_cigar_tuple("")
+    [[], []]
+    >>> build_cigar_tuple("5H10M5H")
+    [['H', 'M', 'H'], [5, 10, 5]]
+    >>> build_cigar_tuple("10MXXX")  # non-CIGAR ignored
+    [['M'], [10]]
+    """
+    import re
+
+    cigar_tuples = [[], []]
+
+    for match in re.finditer(r"(\d+)([MIDNSHP=X])", cigar):
+        times = int(match.group(1))
+        code = match.group(2)
+        cigar_tuples[0].append(code)
+        cigar_tuples[1].append(times)
+    return cigar_tuples
+
+
+def write_read(name, sequence, quality, start, stop):
+    """
+    write a sequence
+
+    Examples
+    --------
+    >>> write_read("@r1", "ACGT", "IIII", 1, 3)
+    '@r1\\nCG\\n+\\nII\\n'
+    >>> write_read("@r1", "ACGT", "IIII", 0, 4)
+    '@r1\\nACGT\\n+\\nIIII\\n'
+    """
+    return (
+        name
+        + "\n"
+        + sequence[start:stop]
+        + "\n"
+        + "+"
+        + "\n"
+        + quality[start:stop]
+        + "\n"
+    )
+
+
+def count_len(cigar_ops, cigar_lens):
+    """
+    Calculates the length consumed in the read (ignores D, N, H, P)
+    and also returns the qpos_before positions (read coordinates
+    at the start of each CIGAR operator).
+
+    Parameters
+    ----------
+    cigar_ops : list of str
+        CIGAR operations, e.g. ['S','M','S'].
+    cigar_lens : list of int
+        Corresponding lengths, e.g. [1,2,1].
+
+    Returns
+    -------
+    qpos_before : list of int
+        Read positions before each CIGAR op.
+    qpos : int
+        Total length consumed in the read.
+
+    Examples
+    --------
+    >>> qpos_before, qpos = count_len(['M', 'I', 'D', 'S'], [5, 2, 3, 4])
+    >>> qpos_before
+    [0, 5, 7, 7]
+    >>> qpos
+    11
+    >>> count_len(['N', 'H', 'P'], [10, 5, 2])
+    ([0, 0, 0], 0)
+    """
+    qpos_before = []
+    qpos = 0
+    for op, ln in zip(cigar_ops, cigar_lens):
+        qpos_before.append(qpos)
+        if op in ("M", "I", "S", "=", "X"):
+            qpos += ln
+        # D, N, H, P doesn't consume the read (len)
+    return qpos_before, qpos
+
+
+def process_cigard(name, sequence, quality, cigar, seed_size, len_add):
+    """
+    Extract fragments in the FastQ format from read
+    Extract mapped fragments and non mapped fragment
+
+    Parameters:
+        read (tuple): The read from which to extract information.
+        seed_size (int): The minimum size of a segment to be considered for extraction.
+        len_add (int): Number of base pairs added to the neoformed fragment after completion of soft clipping.
+
+    Returns:
+        tuple: A tuple containing the read name and a list of FastQ format strings.
+
+    Examples
+    --------
+    Cas sans soft-clip:
+    >>> name, seq, qual, cig = "@r", "ACGT", "IIII", "4M"
+    >>> n, frags = process_cigard(name, seq, qual, cig, seed_size=0, len_add=0)
+    >>> n
+    '@r'
+    >>> frags == ['@r\\nACGT\\n+\\nIIII\\n']
+    True
+
+    # Un soft-clip en tête (ex: 2S2M, len_add=1)
+    >>> name, seq, qual, cig = "@r", "ACGT", "?@AB", "2S2M"
+    >>> n, frags = process_cigard(name, seq, qual, cig, seed_size=0, len_add=1)
+    >>> len(frags)
+    2
+    >>> frags
+    ['@r\\nACG\\n+\\n?@A\\n', '@r\\nCGT\\n+\\n@AB\\n']
+    >>> all(f.startswith('@r\\n') for f in frags)
+    True
+
+    # Deux soft-clips (ex: 1S2M1S), seed_size=1 -> 3 fragments
+    >>> name, seq, qual, cig = "@r", "ACGT", "????", "1S2M1S"
+    >>> n, frags = process_cigard(name, seq, qual, cig, seed_size=1, len_add=0)
+    >>> len(frags)
+    3
+
+    # Deux soft-clips (ex: 1S2M1S), seed_size=2 -> seul fragment central conservé
+    >>> name, seq, qual, cig = "@r", "ACGT", "????", "1S2M1S"
+    >>> n, frags = process_cigard(name, seq, qual, cig, seed_size=2, len_add=0)
+    >>> len(frags)
+    1
+    >>> frags
+    ['@r\\nCG\\n+\\n??\\n']
+
+    # Deux soft-clips (ex: 1S2M1S), seed_size=3 -> fallback read complet
+    >>> name, seq, qual, cig = "@r", "ACGT", "????", "1S2M1S"
+    >>> n, frags = process_cigard(name, seq, qual, cig, seed_size=3, len_add=0)
+    >>> len(frags)
+    1
+    >>> frags
+    ['@r\\nACGT\\n+\\n????\\n']
+    """
+    if cigar in (None, "", "*"):
+        return name, []
+
+    # Build_cigar_tuple retourne [ops_list, lens_list]
+    cigar_ops, cigar_lens = build_cigar_tuple(cigar)
+
+    # Intra reads coordinates
+    qpos_before, _ = count_len(cigar_ops, cigar_lens)
+    read_len = len(sequence)
+
+    soft_clip_indices = [i for i, x in enumerate(cigar_ops) if x in ["S"]]
+
+    def make_frag(start: int, stop: int):
+        """
+        Builds a FastQ fragment:
+            - clamp start/stop in [0, read_len]
+            - filter if length < seed_size
+            - returns None if fragment is invalid
+        """
+        s = max(0, min(read_len, start))
+        e = max(0, min(read_len, stop))
+        if e <= s:
+            return None
+        if seed_size and (e - s) < seed_size:
+            return None
+        return write_read(f"{name}", sequence, quality, s, e)
+
+    # Case 0 : No soft-clipping
+    if len(soft_clip_indices) == 0:
+        return name, [write_read(name, sequence, quality, 0, len(sequence))]
+
+    # Case 1 : One soft-clip
+    if len(soft_clip_indices) == 1:
+        i = soft_clip_indices[0]
+
+        if i == 0:
+            # soft-clip first
+            index = cigar_lens[i]
+            frag1 = make_frag(0, index + len_add)
+            frag2 = make_frag(index - len_add, read_len)
+        else:
+            # soft-clip end
+            index = qpos_before[i]
+            frag1 = make_frag(0, index + len_add)
+            frag2 = make_frag(index - len_add, read_len)
+
+        frags = [f for f in (frag1, frag2) if f is not None]
+
+        # If everything were filtered
+        if not frags:
+            if not seed_size or read_len >= seed_size:
+                return name, [write_read(name, sequence, quality, 0, read_len)]
+        return name, frags
+
+    # Case 2 : Two soft-clips (S ... M ... S)
+    if len(soft_clip_indices) == 2:
+        i0, i1 = soft_clip_indices
+
+        ln0 = cigar_lens[i0]
+        # fin du premier soft-clip en coordonnées read
+        if i0 == 0:
+            index1_end = ln0
+        else:
+            index1_end = qpos_before[i0] + ln0
+
+        # début du second soft-clip en coordonnées read
+        index2_start = qpos_before[i1]
+
+        fragS1 = make_frag(0, index1_end + len_add)
+        fragM = make_frag(index1_end - len_add, index2_start + len_add)
+        fragS2 = make_frag(index2_start - len_add, read_len)
+
+        frags = [f for f in (fragS1, fragM, fragS2) if f is not None]
+
+        if not frags:
+            if not seed_size or read_len >= seed_size:
+                return name, [write_read(name, sequence, quality, 0, read_len)]
+        return name, frags
+
+    # > 2 soft-clips : garde-fou
+    raise ValueError(
+        f"More than two soft clipped segments found in CIGAR string ({cigar}) for read {name}. problem with mapping ?"
+    )
+
+
+def read_name(base_name, tag_i, tag_j, tot_for, tot_rev, tags=None):
+    """
+    Construit un header de paire à partir d'un nom de read et de deux tags.
+
+    base_name : nom logique du read (ex: '@READ')
+    tag_i, tag_j : identifiants de fragments, typiquement 'F1', 'R1', etc. (1-based)
+    tot_for, tot_rev : nombres totaux de fragments forward / reverse
+
+    Retour (mode origin/o):
+        '<base_name>:[<tag_i>,<tag_j>:FT<tot_for>,RT<tot_rev>]'
+
+    Examples
+    --------
+    >>> read_name("@READ", "F1", "R1", 3, 1, "o")
+    '@READ:[F1,R1:FT3,RT1]'
+    >>> read_name("@READ", "F1", "F2", 3, 1, "o")
+    '@READ:[F1,F2:FT3,RT1]'
+    >>> read_name("@READ", "R1", "R2", 0, 2, "o")
+    '@READ:[R1,R2:FT0,RT2]'
+    >>> read_name("@READ", "F1", "F2", 3, 1)
+    '@READ:[F1,F2:FT3,RT1]'
+    >>> read_name("@READ", "X", "Y", 3, 1, "nt")
+    '@READ'
+    >>> read_name("@READ", "X", "Y", 3, 1, "no_tag")
+    '@READ'
+    """
+    if tags in ("no_tag", "nt"):
+        return f"{base_name}"
+    else:
+        return f"{base_name}:[{tag_i},{tag_j}:FT{tot_for},RT{tot_rev}]"
+
+
+def _fraglist_to_entries(frag_list, origin):
+    """
+    Transforme une liste de FastQ en tuples (origin, idx, seq, qual).
+
+    Examples
+    --------
+    >>> _fraglist_to_entries(["@x\\nAC\\n+\\n!!\\n"], "F")
+    [('F', 0, 'AC', '!!')]
+    """
+    entries = []
+    for idx, frag in enumerate(frag_list):
+        lines = frag.strip().split("\n")
+        if len(lines) != 4 or lines[2] != "+":
+            raise ValueError("Fragment FastQ invalide dans process_cigard.")
+        seq = lines[1]
+        qual = lines[3]
+        entries.append((origin, idx, seq, qual))
+    return entries
+
+
+def _emit_pair(base_name, e1, e2, tot_for, tot_rev, tags=None):
+    """
+    Construit une paire FASTQ textuelle à partir de deux entrées.
+
+    e = (origin, idx, seq, qual)
+    """
+    o1, i1, s1, q1 = e1
+    o2, i2, s2, q2 = e2
+
+    tag_i = f"{o1}{i1 + 1}"
+    tag_j = f"{o2}{i2 + 1}"
+    header = read_name(base_name, tag_i, tag_j, tot_for, tot_rev, tags=tags)
+
+    fq_f = f"{header}\n{s1}\n+\n{q1}\n"
+    fq_r = f"{header}\n{s2}\n+\n{q2}\n"
+    return fq_f, fq_r
+
+
+def gen_read_pairs_from_frags_cover(base_name, frags_f, frags_r, tags=None):
+    """
+    Génère un nombre minimal (ou quasi minimal) de paires pour que
+    chaque fragment apparaisse au moins une fois.
+
+    Stratégie:
+    1. appariement F-R tant que possible
+    2. appariement des restes au sein du même côté
+    3. si un fragment reste seul, on le rattache à un anchor déjà utilisé
+
+    Complexité: O(F + R)
+
+    Examples
+    --------
+    Cas 1F / 1R
+    >>> frags_f = ["@x\\nAC\\n+\\n??\\n"]
+    >>> frags_r = ["@x\\nTG\\n+\\n!!\\n"]
+    >>> F, R = gen_read_pairs_from_frags_cover("@READ", frags_f, frags_r)
+    >>> F
+    '@READ:[F1,R1:FT1,RT1]\\nAC\\n+\\n??\\n'
+    >>> R
+    '@READ:[F1,R1:FT1,RT1]\\nTG\\n+\\n!!\\n'
+
+    Cas 2F / 1R -> minimum = ceil(3/2)=2
+    >>> frags_f = ["@x\\nA\\n+\\n=\\n", "@x\\nBC\\n+\\n==\\n"]
+    >>> frags_r = ["@x\\nW\\n+\\n!\\n"]
+    >>> F, R = gen_read_pairs_from_frags_cover("@READ", frags_f, frags_r, tags="o")
+    >>> F.count('@READ:['), R.count('@READ:[')
+    (2, 2)
+    >>> '@READ:[F1,R1:FT2,RT1]' in F
+    True
+
+    Cas 2F / 2R -> minimum = 2
+    >>> frags_f = ["@x\\nA\\n+\\n!\\n", "@x\\nB\\n+\\n!\\n"]
+    >>> frags_r = ["@x\\nC\\n+\\n!\\n", "@x\\nD\\n+\\n!\\n"]
+    >>> F, R = gen_read_pairs_from_frags_cover("@READ", frags_f, frags_r)
+    >>> F.count('@READ:['), R.count('@READ:[')
+    (2, 2)
+
+    Cas 4F / 1R -> minimum = ceil(5/2)=3
+    >>> frags_f = ["@x\\nA\\n+\\n!\\n", "@x\\nB\\n+\\n!\\n", "@x\\nC\\n+\\n!\\n", "@x\\nD\\n+\\n!\\n"]
+    >>> frags_r = ["@x\\nZ\\n+\\n!\\n"]
+    >>> F, R = gen_read_pairs_from_frags_cover("@READ", frags_f, frags_r)
+    >>> F.count('@READ:['), R.count('@READ:[')
+    (3, 3)
+    """
+    for_entries = _fraglist_to_entries(frags_f, "F")
+    rev_entries = _fraglist_to_entries(frags_r, "R")
+
+    tot_for = len(for_entries)
+    tot_rev = len(rev_entries)
+
+    if tot_for + tot_rev < 2:
+        return ["", ""]
+
+    out_f = []
+    out_r = []
+
+    used_pairs = []
+
+    # 1) Apparier F-R autant que possible
+    n_cross = min(tot_for, tot_rev)
+    for i in range(n_cross):
+        p = (for_entries[i], rev_entries[i])
+        used_pairs.append(p)
+
+    # 2) Gérer les restes d'un seul côté
+    if tot_for > tot_rev:
+        leftovers = for_entries[n_cross:]
+        opposite_anchor = rev_entries[0] if rev_entries else None
+    else:
+        leftovers = rev_entries[n_cross:]
+        opposite_anchor = for_entries[0] if for_entries else None
+
+    # Paires internes sur les restes
+    j = 0
+    while j + 1 < len(leftovers):
+        used_pairs.append((leftovers[j], leftovers[j + 1]))
+        j += 2
+
+    # 3) S'il reste un fragment seul, le raccrocher à un anchor
+    if j < len(leftovers):
+        last = leftovers[j]
+        if opposite_anchor is not None:
+            used_pairs.append((last, opposite_anchor))
+        elif len(leftovers) >= 2:
+            used_pairs.append((last, leftovers[0]))
+        else:
+            # Cas pathologique : un seul fragment total
+            return ["", ""]
+
+    for e1, e2 in used_pairs:
+        fq_f, fq_r = _emit_pair(base_name, e1, e2, tot_for, tot_rev, tags=tags)
+        out_f.append(fq_f)
+        out_r.append(fq_r)
+
+    return ["".join(out_f), "".join(out_r)]
+
+
+def gen_read_pairs_from_frags_all(base_name, frags_f, frags_r, tags=None):
+    """
+    Génère deux chaînes FastQ (forward/reverse) à partir de fragments déjà splittés.
+
+    `frags_f` et `frags_r` sont des listes de fragments FASTQ complets:
+        '@name\\nSEQ\\n+\\nQUAL\\n'
+
+    Examples
+    --------
+    Cas simple : 1 fragment forward, 1 fragment reverse (une seule combinaison).
+    >>> frags_f = ["@x\\nAC\\n+\\n??\\n"]
+    >>> frags_r = ["@x\\nTG\\n+\\n!!\\n"]
+    >>> F, R = gen_read_pairs_from_frags_all("@READ", frags_f, frags_r)
+    >>> F
+    '@READ:[F1,R1:FT1,RT1]\\nAC\\n+\\n??\\n'
+    >>> R
+    '@READ:[F1,R1:FT1,RT1]\\nTG\\n+\\n!!\\n'
+
+    Même cas, sans tag (nt).
+    >>> F, R = gen_read_pairs_from_frags_all("@READ", frags_f, frags_r, tags="nt")
+    >>> F
+    '@READ\\nAC\\n+\\n??\\n'
+    >>> R
+    '@READ\\nTG\\n+\\n!!\\n'
+
+    Cas combinatoire :
+      - forward: 2 fragments (F0, F1)
+      - reverse: 1 fragment (R0)
+      -> combinaisons : (F0,F1), (F0,R0), (F1,R0)
+    >>> frags_f = ["@x\\nA\\n+\\n=\\n", "@x\\nBCD\\n+\\n===\\n"]
+    >>> frags_r = ["@x\\nWXYZ\\n+\\n>>>>\\n"]
+    >>> F, R = gen_read_pairs_from_frags_all("@READ", frags_f, frags_r, tags="o")
+    >>> F.count('@READ:['), R.count('@READ:[')
+    (3, 3)
+    >>> '@READ:[F1,F2:FT2,RT1]' in F
+    True
+    >>> '@READ:[F1,R1:FT2,RT1]' in F
+    True
+    >>> '@READ:[F2,R1:FT2,RT1]' in F
+    True
+    >>> '@@' in F or '@@' in R
+    False
+    >>> F
+    '@READ:[F1,F2:FT2,RT1]\\nA\\n+\\n=\\n@READ:[F1,R1:FT2,RT1]\\nA\\n+\\n=\\n@READ:[F2,R1:FT2,RT1]\\nBCD\\n+\\n===\\n'
+    >>> R
+    '@READ:[F1,F2:FT2,RT1]\\nBCD\\n+\\n===\\n@READ:[F1,R1:FT2,RT1]\\nWXYZ\\n+\\n>>>>\\n@READ:[F2,R1:FT2,RT1]\\nWXYZ\\n+\\n>>>>\\n'
+
+    Cas combinatoire symétrique (2 fragments forward, 2 fragments reverse).
+    >>> frags_f = ["@x\\nA\\n+\\n!\\n", "@x\\nBC\\n+\\n!!\\n"]
+    >>> frags_r = ["@x\\nD\\n+\\n#\\n", "@x\\nEF\\n+\\n##\\n"]
+    >>> F, R = gen_read_pairs_from_frags_all("@READ", frags_f, frags_r)
+    >>> # 4 fragments total => C(4,2) = 6 paires
+    >>> F.count('@READ:['), R.count('@READ:[')
+    (6, 6)
+    """
+    from itertools import combinations
+
+    # Cas combinatoire: on annote chaque fragment avec son origine (F/R) et un index local
+    def _to_entries(frag_list, origin):
+        """
+        Transforme une liste de FastQ en tuples (origin, idx, seq, qual).
+        frag = '@smth\\nSEQ\\n+\\nQUAL\\n'
+        """
+        entries = []
+        for idx, frag in enumerate(frag_list):
+            lines = frag.strip().split("\n")
+            if len(lines) != 4 or lines[2] != "+":
+                raise ValueError("Fragment FastQ invalide dans process_cigard.")
+            seq = lines[1]
+            qual = lines[3]
+            entries.append((origin, idx, seq, qual))
+        return entries
+
+    for_entries = _to_entries(frags_f, "F")
+    tot_for = len(for_entries)
+    rev_entries = _to_entries(frags_r, "R")
+    tot_rev = len(rev_entries)
+    all_entries = for_entries + rev_entries
+
+    fastq_forward = []
+    fastq_reverse = []
+
+    # Toutes les combinaisons uniques (i < j)
+    for (o1, i1, s1, q1), (o2, i2, s2, q2) in combinations(all_entries, 2):
+        tag_i = f"{o1}{i1 + 1}"
+        tag_j = f"{o2}{i2 + 1}"
+        header = read_name(base_name, tag_i, tag_j, tot_for, tot_rev, tags=tags)
+        fastq_forward.append(f"{header}\n{s1}\n+\n{q1}\n")
+        fastq_reverse.append(f"{header}\n{s2}\n+\n{q2}\n")
+
+    return ["".join(fastq_forward), "".join(fastq_reverse)]
+
+
+def gen_read_pairs_from_frags(
+    base_name, frags_f, frags_r, tags=None, pairing_mode="all"
+):
+    """
+    Dispatcher entre plusieurs stratégies de génération de paires.
+    """
+    if pairing_mode == "all":
+        return gen_read_pairs_from_frags_all(base_name, frags_f, frags_r, tags=tags)
+    elif pairing_mode == "cover":
+        return gen_read_pairs_from_frags_cover(base_name, frags_f, frags_r, tags=tags)
+    else:
+        raise ValueError(f"Unknown pairing_mode: {pairing_mode}")
+
+
+# Pensez à la gestion de seq = "*"
+def sam_fields(sam_line: str):
+    """
+    Return minimal information
+    """
+    f = sam_line.rstrip("\n").split("\t")
+    if len(f) < 11:
+        raise ValueError(
+            f"Malformed SAM line: expected >= 11 fields : \n {sam_line}\n\n"
+        )
+    qname = f[0]
+    cigar = f[5]
+    seq = f[9]
+    qual = f[10]
+
+    name = qname if qname.startswith("@") else f"@{qname}"
+    return name, seq, qual, cigar
+
+
+def process_items(
+    input_queue,
+    output_queue,
+    bam_queue,
+    seed_size,
+    len_add,
+    tags=None,
+    bam_batch_size=1000,
+    fastq_batch_items=1250,
+    pairing_mode="cover",
+):
+    """
+    Process items from the input queue, split the reads based on CIGAR strings, and put the results into the output queue.
+
+    Parameters:
+        input_queue (Queue): Queue to get read pairs.
+        output_queue (Queue): Queue to put processed read pairs.
+        seed_size (int): The minimum size of a segment to be considered for extraction.
+
+    Examples
+    --------
+    """
+
+    def flush_bam(buf):
+        if buf:
+            bam_queue.put(buf)
+            buf.clear()
+
+    def flush_fastq(f_chunks, r_chunks):
+        if f_chunks:
+            output_queue.put(("".join(f_chunks), "".join(r_chunks)))
+            f_chunks.clear()
+            r_chunks.clear()
+
+    bam_buf = []
+    fq_f_chunks = []
+    fq_r_chunks = []
+    fastq_forward = ""
+    fastq_reverse = ""
+    try:
+        while True:
+            batch = input_queue.get()
+            if batch is None:
+                # Flush restant
+                flush_bam(bam_buf)
+                flush_fastq(fq_f_chunks, fq_r_chunks)
+                # Signal fin à chaque writer
+                output_queue.put(None)
+                bam_queue.put(None)
+                break
+
+            # batch = list[(sam_f, sam_r)]
+            for sam_f, sam_r in batch:
+                name_f, seq_f, qual_f, cig_f = sam_fields(sam_f)
+                name_r, seq_r, qual_r, cig_r = sam_fields(sam_r)
+                if name_f != name_r:
+                    raise ValueError("File / Pairs unsynchronized")
+
+                if check_data(
+                    (name_f, seq_f, qual_f, cig_f, name_r, seq_r, qual_r, cig_r)
+                ):
+                    # Decisionmaking "splittable"  FAST PATH: dodge processing for a large part of pairs
+                    if ("S" not in str(cig_f) and "S" not in str(cig_r)) or (
+                        cig_f == "*" and cig_r == "*"
+                    ):
+                        # Unsplittable
+                        bam_buf.append((sam_f, sam_r))
+                        if len(bam_buf) >= bam_batch_size:
+                            flush_bam(bam_buf)
+                        continue
+
+                    base_name, frags_f = process_cigard(
+                        name=name_f,
+                        sequence=seq_f,
+                        quality=qual_f,
+                        cigar=cig_f,
+                        seed_size=seed_size,
+                        len_add=len_add,
+                    )
+                    _, frags_r = process_cigard(
+                        name=name_r,
+                        sequence=seq_r,
+                        quality=qual_r,
+                        cigar=cig_r,
+                        seed_size=seed_size,
+                        len_add=len_add,
+                    )
+
+                    if (len(frags_f) == 1) and (len(frags_r) == 1):
+                        # unsplittable/unique : Write in BAM
+                        bam_buf.append((sam_f, sam_r))
+                        if len(bam_buf) >= bam_batch_size:
+                            flush_bam(bam_buf)
+                        continue
+
+                    if len(frags_f) + len(frags_r) < 2:
+                        # unsplittable/unique : Write in BAM
+                        bam_buf.append((sam_f, sam_r))
+                        if len(bam_buf) >= bam_batch_size:
+                            flush_bam(bam_buf)
+                        continue
+
+                    fastq_forward, fastq_reverse = gen_read_pairs_from_frags(
+                        base_name=base_name,
+                        frags_f=frags_f,
+                        frags_r=frags_r,
+                        tags=tags,
+                        pairing_mode=pairing_mode,
+                    )
+
+                    if not fastq_forward or not fastq_reverse:
+                        bam_buf.append((sam_f, sam_r))
+                        if len(bam_buf) >= bam_batch_size:
+                            flush_bam(bam_buf)
+                        continue
+
+                    fq_f_chunks.append(fastq_forward)
+                    fq_r_chunks.append(fastq_reverse)
+
+                    if len(fq_f_chunks) >= fastq_batch_items:
+                        flush_fastq(fq_f_chunks, fq_r_chunks)
+
+        if len(fq_f_chunks) > 0:
+            flush_fastq(fq_f_chunks, fq_r_chunks)
+        if len(bam_buf) > 0:
+            flush_bam(bam_buf)
+
+    except Exception as e:
+        try:
+            output_queue.put(None)
+            bam_queue.put(None)
+        except Exception:
+            pass
+        print(f"Error in process_items: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def cut(args):
+    """
+    Main function to orchestrate the reading, processing, and writing of BAM files to FastQ.
+
+    Parameters:
+        args (argparse.Namespace): Namespace object containing command-line arguments.
+    """
+    bam_for_file = args.bam_1
+    bam_rev_file = args.bam_2
+    single_bam = args.single_bam
+
+    output_forward = args.output_forward
+    output_reverse = args.output_reverse
+    num_threads = args.num_threads
+    seed_size = args.seed_size
+    len_add = args.lenght_added
+    tags = args.tags
+    pairing_mode = args.pairing_mode
+
+    if single_bam:
+        if not os.path.exists(bam_for_file):
+            logger.error("Single BAM file does not exist.")
+            sys.exit(1)
+    else:
+        if not os.path.exists(bam_for_file) or not os.path.exists(bam_rev_file):
+            logger.error("BAM file does not exist.")
+            sys.exit(1)
+
+    try:
+        print("Extracting BAM headers...", flush=True)
+        if single_bam:
+            header_single = get_bam_header_single(bam_for_file)
+        else:
+            header_for, header_rev = get_bam_headers(bam_for_file, bam_rev_file)
+    except Exception as e:
+        print(f"Error reading BAM headers: {e}")
+        sys.exit(1)
+
+    if single_bam:
+        output_bam_single = str(args.output_forward.split(".")[0]) + "_unsplit.bam"
+    else:
+        output_bam_f = str(args.output_forward.split(".")[0]) + "_unsplit.bam"
+        output_bam_r = str(args.output_reverse.split(".")[0]) + "_unsplit.bam"
+
+    input_queue = Queue(maxsize=750)
+    output_queue = Queue(maxsize=100)
+    unsplittable_queue = Queue(maxsize=100)
+
+    try:
+        pigz_per_file, compute_processes, bam_threads = partitionning(
+            num_threads,
+            single_bam=single_bam,
+        )
+    except ValueError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        return 2
+
+    handle_write_cmd(
+        bam_1=bam_for_file,
+        bam_2=bam_rev_file if not single_bam else None,
+        output_fq1=output_forward,
+        output_fq2=output_reverse,
+        output_bam1=output_bam_single if single_bam else output_bam_f,
+        output_bam2=None if single_bam else output_bam_r,
+        args=args,
+    )
+
+    manager = ProcessManager()
+    signal.signal(signal.SIGINT, manager.handle_signal)
+    signal.signal(signal.SIGTERM, manager.handle_signal)
+
+    try:
+        # Reader
+        if single_bam:
+            manager.start_worker(
+                target=read_bam_interleaved,
+                args=(
+                    bam_for_file,
+                    input_queue,
+                    compute_processes,
+                    bam_threads,
+                ),
+            )
+        else:
+            manager.start_worker(
+                target=read_bam_pair,
+                args=(
+                    bam_for_file,
+                    bam_rev_file,
+                    input_queue,
+                    compute_processes,
+                    bam_threads,
+                ),
+            )
+
+        # Compute workers
+        for _ in range(compute_processes):
+            manager.start_worker(
+                target=process_items,
+                args=(
+                    input_queue,
+                    output_queue,
+                    unsplittable_queue,
+                    seed_size,
+                    len_add,
+                    tags,
+                    1000,
+                    1250,
+                    pairing_mode,
+                ),
+            )
+
+        # FASTQ writer
+        manager.start_worker(
+            target=write_fastq_pair,
+            args=(
+                output_queue,
+                output_forward,
+                output_reverse,
+                compute_processes,
+                pigz_per_file,
+            ),
+        )
+
+        # BAM writer
+        if single_bam:
+            manager.start_worker(
+                target=write_bam_interleaved_from_sam,
+                args=(
+                    unsplittable_queue,
+                    output_bam_single,
+                    header_single,
+                    compute_processes,
+                    bam_threads,
+                ),
+            )
+        else:
+            manager.start_worker(
+                target=write_bam_pair_from_sam,
+                args=(
+                    unsplittable_queue,
+                    output_bam_f,
+                    output_bam_r,
+                    header_for,
+                    header_rev,
+                    compute_processes,
+                    bam_threads,
+                ),
+            )
+
+        while manager.running():
+            if not manager.check_processes():
+                sys.exit(1)
+            time.sleep(1)
+
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        manager.shutdown()
+        return 2
+    finally:
+        manager.shutdown()