split3c 0.0.1__py3-none-any.whl

split3c/resite/__init__.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: 2025 2024 Samir Bertache
+#
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""
+This script is a the Parasplit project, designed to process paired-end FASTQ files by fragmenting DNA sequences at specified restriction enzyme sites.
+
+Copyright © 2024 Samir Bertache
+
+SPDX-License-Identifier: AGPL-3.0-or-later
+
+===============================================================================
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU Affero General Public License as published by the
+Free Software Foundation, either version 3 of the License, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+See the GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+
+from .frag import process_items
+from .pretreatment import partition_threads, search_in_database
+from .read import read_fastq_gzip_simultaneously
+from .write_control import manage_pigz_problems, open_output, write_pairs
+
+__version__ = "1.1.5"

split3c/resite/frag.py

@@ -0,0 +1,576 @@
+"""
+This script is a the split3c project, designed to process paired-end FASTQ files by fragmenting DNA sequences at specified restriction enzyme sites.
+
+Copyright © 2024 Samir Bertache
+
+SPDX-License-Identifier: AGPL-3.0-or-later
+
+===============================================================================
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU Affero General Public License as published by the
+Free Software Foundation, either version 3 of the License, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+See the GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+
+import logging
+import re
+from typing import Generator, List, Tuple
+
+from .header import _tag_from_global_index, build_pair_header
+from .index import index_list, index_list_borderless
+
+logging.basicConfig(level=logging.INFO)
+
+
+################################ Mode All #####################################
+
+
+def create_pairs_all(sequence, seed_size, ligation_site_list, indexation) -> Generator:
+    """
+    Create all possible pairs of fragments from given sequences.
+
+    Parameters:
+        Sequence (List[str]): List containing forward and reverse sequences.
+        seed_size (int): Minimum size of the fragment to be considered.
+        ligation_site_list (List[Tuple[re.Pattern, int]]): List of ligation sites with regex patterns and offsets.
+
+    Yields:
+        List: A list containing:
+            - A unique identifier for the pair.
+            - Information about the first fragment and which sequence it comes from (forward or reverse).
+            - Information about the second fragment and which sequence it comes from (forward or reverse).
+
+    >>> seqs = ["AAAACCCCGGGG", "TTTTGGGGCCCC"]
+    >>> quals = ["IIIIIIIIIIII", "JJJJJJJJJJJJ"]
+    >>> def fake_index(Seq, sites, seed): return ([[0,12]], [[0,12]])
+    >>> lig = [(re.compile("CCCC"),4)]
+    >>> bufF, bufR = processing_all("readX", seqs, quals, lig, 0, fake_index, tags="o")
+    >>> bufF[0].startswith("readX\\n")
+    True
+    >>> bufR[0].startswith("readX\\n")
+    True
+
+    >>> # tags=None doit se comporter comme tags="o" quand multipaires
+    >>> def fake_index2(Seq, sites, seed): return ([[0,6],[6,12]], [[0,6],[6,12]])
+    >>> bufF2, bufR2 = processing_all("readY", seqs, quals, lig, 0, fake_index2, tags=None)
+    >>> len(bufF2), len(bufR2)
+    (6, 6)
+    >>> any("readY:[F1,F2:FT2,RT2]\\n" in x for x in bufF2)
+    True
+    >>> any("readY:[R1,R2:FT2,RT2]\\n" in x for x in bufF2)
+    True
+
+    >>> def fake_index2(Seq, sites, seed): return ([[0,6],[6,12]], [[0,6],[6,12]])
+    >>> bufF2, bufR2 = processing_all("readY", seqs, quals, lig, 0, fake_index2, tags="o")
+    >>> len(bufF2), len(bufR2)
+    (6, 6)
+    >>> any("readY:[F1,F2:FT2,RT2]\\n" in x for x in bufF2)
+    True
+    >>> any("readY:[R1,R2:FT2,RT2]\\n" in x for x in bufF2)
+    True
+
+
+    >>> # 1 fragment sur R1, 1 fragment sur R2 => 1 paire (F1,R1)
+    >>> def idx_1_1(Seq, sites, seed): return ([[0,2]], [[0,2]])
+    >>> pairs = list(create_pairs_all(["AB", "CD"], 0, [], idx_1_1))
+    >>> len(pairs)
+    1
+    >>> pair_id, tag_i, tag_j, fragA, fragB, tot_for, tot_rev = pairs[0]
+    >>> (tag_i, tag_j, tot_for, tot_rev)
+    ('F1', 'R1', 1, 1)
+    >>> # fragA vient de R1 (which=0), fragB vient de R2 (which=1)
+    >>> (fragA[1], fragB[1])
+    (0, 1)
+
+    >>> # 2 fragments sur R1, 2 fragments sur R2 => 4 fragments => C(4,2)=6 paires
+    >>> def idx_2_2(Seq, sites, seed): return ([[0,6],[6,12]], [[0,6],[6,12]])
+    >>> seqs = ["AAAACCCCGGGG", "TTTTGGGGCCCC"]
+    >>> pairs = list(create_pairs_all(seqs, 0, [], idx_2_2))
+    >>> len(pairs)
+    6
+    >>> # Dernière paire = (R1,R2) (car ordre i<j sur AllFrag = F1,F2,R1,R2)
+    >>> pairs[-1][1], pairs[-1][2]
+    ('R1', 'R2')
+    >>> # et les deux fragments viennent bien de la séquence reverse (which=1)
+    >>> pairs[-1][3][1], pairs[-1][4][1]
+    (1, 1)
+    """
+    ListFragmentFor, ListFragmentRev = indexation(
+        sequence, ligation_site_list, seed_size
+    )
+    AllFrag = ListFragmentFor + ListFragmentRev
+    NbFragFor = len(ListFragmentFor)
+    NbFragRev = len(ListFragmentRev)
+
+    for i, fragI in enumerate(AllFrag):
+        for j, fragJ in enumerate(AllFrag):
+            if i < j:
+                tag_i = _tag_from_global_index(i, NbFragFor)
+                tag_j = _tag_from_global_index(j, NbFragFor)
+
+                which_i = 0 if i < NbFragFor else 1
+                which_j = 0 if j < NbFragFor else 1
+
+                pair_id = f"{i}{j}"
+                yield [
+                    pair_id,
+                    tag_i,
+                    tag_j,
+                    [fragI, which_i],
+                    [fragJ, which_j],
+                    NbFragFor,
+                    NbFragRev,
+                ]
+
+
+def processing_all(
+    Name: str,
+    Sequence: List[str],
+    Quality: List[str],
+    ligation_site_list: List[Tuple[re.Pattern, int]],
+    seed_size: int,
+    indexation,
+    tags: str | None = None,
+) -> Tuple[List[str], List[str]]:
+    """
+    Process the sequences to generate buffers for forward and reverse reads
+    by creating ALL possible fragment pairs. Do not add the suffix :ij if there is only one pair.
+
+    Returns:
+        bufferF, bufferR: deux listes de lignes FastQ.
+
+    Doctests:
+        >>> seqs = ["AAAACCCCGGGG", "TTTTGGGGCCCC"]
+        >>> quals = ["IIIIIIIIIIII", "JJJJJJJJJJJJ"]
+        >>> def fake_index(Seq, sites, seed): return ([[0,12]], [[0,12]])
+        >>> lig = [(re.compile("CCCC"),4)]
+        >>> bufF, bufR = processing_all("readX", seqs, quals, lig, 0, fake_index, tags="o")
+        >>> bufF[0].startswith("readX\\n")
+        True
+        >>> bufR[0].startswith("readX\\n")
+        True
+
+        >>> def fake_index2(Seq, sites, seed): return ([[0,6],[6,12]], [[0,6],[6,12]])
+        >>> bufF2, bufR2 = processing_all("readY", seqs, quals, lig, 0, fake_index2, tags="o")
+        >>> # 4 fragments total => C(4,2)=6 paires, donc 6 entrées
+        >>> len(bufF2), len(bufR2)
+        (6, 6)
+        >>> any("readY:[F1,F2:FT2,RT2]\\n" in x for x in bufF2)
+        True
+        >>> any("readY:[R1,R2:FT2,RT2]\\n" in x for x in bufF2)
+        True
+        >>> # 1ère paire = (F1,F2) donc forward=seqs[0][0:6], reverse=seqs[0][6:12]
+        >>> bufF2[0].splitlines()[1], bufR2[0].splitlines()[1]
+        ('AAAACC', 'CCGGGG')
+        >>> # dernière paire = (R1,R2) donc forward=seqs[1][0:6], reverse=seqs[1][6:12]
+        >>> bufF2[-1].splitlines()[0].startswith("readY:[R1,R2:FT2,RT2]")
+        True
+        >>> bufF2[-1].splitlines()[1], bufR2[-1].splitlines()[1]
+        ('TTTTGG', 'GGCCCC')
+
+
+        >>> from itertools import combinations
+        >>> def microsplit_like_all(name, seqs, quals, fr_for, fr_rev):
+        ...     entries = []
+        ...     for k, (s,e) in enumerate(fr_for):
+        ...         entries.append(("F", k, seqs[0][s:e], quals[0][s:e]))
+        ...     for k, (s,e) in enumerate(fr_rev):
+        ...         entries.append(("R", k, seqs[1][s:e], quals[1][s:e]))
+        ...     tot_for = len(fr_for); tot_rev = len(fr_rev)
+        ...     outF, outR = [], []
+        ...     for (o1,i1,s1,q1), (o2,i2,s2,q2) in combinations(entries, 2):
+        ...         tag_i = f"{o1}{i1+1}"
+        ...         tag_j = f"{o2}{i2+1}"
+        ...         header = f"{name}:[{tag_i},{tag_j}:FT{tot_for},RT{tot_rev}]"
+        ...         outF.append(f"{header}\\n{s1}\\n+\\n{q1}\\n")
+        ...         outR.append(f"{header}\\n{s2}\\n+\\n{q2}\\n")
+        ...     return outF, outR
+        >>> seqs = ["AAAACCCCGGGG", "TTTTGGGGCCCC"]
+        >>> quals = ["IIIIIIIIIIII", "JJJJJJJJJJJJ"]
+        >>> def idx_2_2(Seq, sites, seed): return ([[0,6],[6,12]], [[0,6],[6,12]])
+        >>> bufF3, bufR3 = processing_all("readY", seqs, quals, lig, 0, idx_2_2, tags="o")
+        >>> expF, expR = microsplit_like_all("readY", seqs, quals, [[0,6],[6,12]], [[0,6],[6,12]])
+        >>> bufF3 == expF and bufR3 == expR
+        True
+    """
+    bufferF = []
+    bufferR = []
+
+    # Collect all pairs
+    all_pairs = [
+        pair
+        for pair in create_pairs_all(
+            Sequence, seed_size, ligation_site_list, indexation
+        )
+    ]
+    single_pair = len(all_pairs) == 1
+
+    for _, tag_i, tag_j, fragA, fragB, tot_for, tot_rev in all_pairs:
+        header = build_pair_header(
+            raw_name=Name,
+            tag_i=tag_i,
+            tag_j=tag_j,
+            tot_for=tot_for,
+            tot_rev=tot_rev,
+            tags=tags,
+            single_pair=single_pair,
+        )
+        # forward
+        frag_for, which_for = fragA
+        seq_f = Sequence[which_for][frag_for[0] : frag_for[1]]
+        qual_f = Quality[which_for][frag_for[0] : frag_for[1]]
+        bufferF.append(f"{header}\n{seq_f}\n+\n{qual_f}\n")
+
+        # reverse
+        frag_rev, which_rev = fragB
+        seq_r = Sequence[which_rev][frag_rev[0] : frag_rev[1]]
+        qual_r = Quality[which_rev][frag_rev[0] : frag_rev[1]]
+        bufferR.append(f"{header}\n{seq_r}\n+\n{qual_r}\n")
+
+    return bufferF, bufferR
+
+
+################################ Mode FR #####################################
+
+
+def create_pairs_fr(fragments):
+    """
+    Create pairs of forward and reverse fragments.
+
+    Parameters:
+        fragments (List[List[List[int]]]): List containing forward and reverse fragments. Each fragment is a list of start and end indices.
+
+    Yields:
+        List: A list containing:
+            - A unique identifier for the pair.
+            - The forward fragment indices.
+            - The reverse fragment indices.
+
+    """
+    forward_fragments = fragments[0]
+    reverse_fragments = fragments[1]
+    for i, index_f_frag in enumerate(forward_fragments):
+        for j, index_r_frag in enumerate(reverse_fragments):
+            pair_id = str(i) + str(j)
+            tag_i = f"F{i + 1}"
+            tag_j = f"R{j + 1}"
+            yield [
+                pair_id,
+                tag_i,
+                tag_j,
+                index_f_frag,
+                index_r_frag,
+                len(forward_fragments),
+                len(reverse_fragments),
+            ]
+
+
+def processing_fr(
+    TNom: str,
+    TSeq: List[str],
+    TQual: List[str],
+    ligation_site_list: List[Tuple[re.Pattern, int]],
+    seed_size: int,
+    indexation,
+    tags: str | None = None,
+) -> Tuple[List[str], List[str]]:
+    """
+    Process the sequences to generate buffers for forward and reverse reads
+    selon le mode FR (un fragment forward + un fragment reverse).
+    N'ajoute pas de suffixe :ij si une seule paire.
+
+    Doctests:
+    >>> seqs = ["AAAACCCCGGGG", "TTTTGGGGCCCC"]
+    >>> quals = ["IIIIIIIIIIII", "JJJJJJJJJJJJ"]
+    >>> def idx_fr(seq, lig, sd): return ([[0,6]], [[6,12]])
+    >>> bufF, bufR = processing_fr("readZ", seqs, quals, [], 0, idx_fr, tags="o")
+    >>> bufF
+    ['readZ\\nAAAACC\\n+\\nIIIIII\\n']
+    >>> bufR
+    ['readZ\\nGGCCCC\\n+\\nJJJJJJ\\n']
+
+    >>> # Avec suffixe
+    >>> def idx_fr2(seq, lig, sd): return ([[0,6],[6,12]], [[0,6],[6,12]])
+    >>> bufF2, bufR2 = processing_fr("readW", seqs, quals, [], 0, idx_fr2)  # tags=None => "o"
+    >>> len(bufF2), len(bufR2)
+    (4, 4)
+    >>> any(x.startswith("readW:[F1,R1:FT2,RT2]\\n") for x in bufF2)
+    True
+    >>> any(x.startswith("readW:[F2,R2:FT2,RT2]\\n") for x in bufF2)
+    True
+
+    >>> bufFna, bufRna = processing_fr("readW", seqs, quals, [], 0, idx_fr2, tags="na")
+    >>> len(bufFna), len(bufRna)
+    (4, 4)
+    >>> all(x.startswith("readW\\n") for x in bufFna)
+    True
+
+    >>> seqs = ["ABCDEFGH", "IJKLMNOP"]
+    >>> quals = ["!!!!!!!!", "????????"]
+    >>> def idx_fr(seq, lig, sd): return ([[0,2]], [[2,4]])
+    >>> bufF, bufR = processing_fr("readZ", seqs, quals, [], 0, idx_fr, tags="o")
+    >>> bufF[0].splitlines()[1], bufR[0].splitlines()[1]
+    ('AB', 'KL')
+    """
+    bufferF = []
+    bufferR = []
+
+    # liste des fragments forward et reverse
+    ListFragFor, ListFragRev = indexation(TSeq, ligation_site_list, seed_size)
+    all_pairs = list(create_pairs_fr([ListFragFor, ListFragRev]))
+    single_pair = len(all_pairs) == 1
+
+    for (
+        _,
+        tag_i,
+        tag_j,
+        index_f_frag,
+        index_r_frag,
+        tot_for,
+        tot_rev,
+    ) in all_pairs:
+        header = build_pair_header(
+            raw_name=TNom,
+            tag_i=tag_i,
+            tag_j=tag_j,
+            tot_for=tot_for,
+            tot_rev=tot_rev,
+            tags=tags,
+            single_pair=single_pair,
+        )
+        seq_f = TSeq[0][index_f_frag[0] : index_f_frag[1]]
+        qual_f = TQual[0][index_f_frag[0] : index_f_frag[1]]
+        bufferF.append(f"{header}\n{seq_f}\n+\n{qual_f}\n")
+
+        seq_r = TSeq[1][index_r_frag[0] : index_r_frag[1]]
+        qual_r = TQual[1][index_r_frag[0] : index_r_frag[1]]
+        bufferR.append(f"{header}\n{seq_r}\n+\n{qual_r}\n")
+
+    return bufferF, bufferR
+
+
+############################## Mode Cover ###################################
+
+
+def create_pairs_cover(
+    sequence, seed_size, ligation_site_list, indexation
+) -> Generator:
+    """
+    Create a minimal / near-minimal set of pairs such that every fragment
+    appears at least once.
+
+    Strategy
+    --------
+    1. Pair forward and reverse fragments one-to-one while both sides exist.
+    2. Pair leftover fragments on the larger side two-by-two.
+    3. If one leftover fragment remains, attach it to an anchor fragment that
+       has already been used if possible.
+
+    Yields
+    ------
+    Same layout as create_pairs_all:
+        [pair_id, tag_i, tag_j, [fragI, which_i], [fragJ, which_j], NbFragFor, NbFragRev]
+
+    Examples
+    --------
+    >>> def idx_2_1(Seq, sites, seed): return ([[0,2],[2,4]], [[0,2]])
+    >>> pairs = list(create_pairs_cover(["ABCD", "EF"], 0, [], idx_2_1))
+    >>> len(pairs)
+    2
+    >>> [(p[1], p[2]) for p in pairs]
+    [('F1', 'R1'), ('F2', 'R1')]
+
+    >>> def idx_2_2(Seq, sites, seed): return ([[0,2],[2,4]], [[0,2],[2,4]])
+    >>> pairs = list(create_pairs_cover(["ABCD", "EFGH"], 0, [], idx_2_2))
+    >>> len(pairs)
+    2
+    >>> [(p[1], p[2]) for p in pairs]
+    [('F1', 'R1'), ('F2', 'R2')]
+    """
+    ListFragmentFor, ListFragmentRev = indexation(
+        sequence, ligation_site_list, seed_size
+    )
+    NbFragFor = len(ListFragmentFor)
+    NbFragRev = len(ListFragmentRev)
+
+    if NbFragFor + NbFragRev < 2:
+        return
+
+    for_entries = [(f"F{i + 1}", [frag, 0]) for i, frag in enumerate(ListFragmentFor)]
+    rev_entries = [(f"R{i + 1}", [frag, 1]) for i, frag in enumerate(ListFragmentRev)]
+
+    used_pairs = []
+
+    # 1) Pair F/R while possible
+    n_cross = min(NbFragFor, NbFragRev)
+    for i in range(n_cross):
+        used_pairs.append((for_entries[i], rev_entries[i]))
+
+    # 2) Leftovers on the larger side
+    if NbFragFor > NbFragRev:
+        leftovers = for_entries[n_cross:]
+        opposite_anchor = rev_entries[0] if rev_entries else None
+        same_anchor = for_entries[0] if for_entries else None
+    else:
+        leftovers = rev_entries[n_cross:]
+        opposite_anchor = for_entries[0] if for_entries else None
+        same_anchor = rev_entries[0] if rev_entries else None
+
+    j = 0
+    while j + 1 < len(leftovers):
+        used_pairs.append((leftovers[j], leftovers[j + 1]))
+        j += 2
+
+    # 3) One last leftover -> attach to an already used anchor
+    if j < len(leftovers):
+        last = leftovers[j]
+        if opposite_anchor is not None:
+            used_pairs.append((last, opposite_anchor))
+        elif same_anchor is not None and same_anchor[0] != last[0]:
+            used_pairs.append((last, same_anchor))
+        else:
+            return
+
+    for pair_id, (e1, e2) in enumerate(used_pairs):
+        tag_i, fragA = e1
+        tag_j, fragB = e2
+        yield [
+            str(pair_id),
+            tag_i,
+            tag_j,
+            fragA,
+            fragB,
+            NbFragFor,
+            NbFragRev,
+        ]
+
+
+def processing_cover(
+    Name: str,
+    Sequence: List[str],
+    Quality: List[str],
+    ligation_site_list: List[Tuple[re.Pattern, int]],
+    seed_size: int,
+    indexation,
+    tags: str | None = None,
+) -> Tuple[List[str], List[str]]:
+    """
+    Process sequences using COVER mode:
+    generate only enough pairs so that each fragment appears at least once.
+
+    Examples
+    --------
+    >>> seqs = ["AAAACCCC", "TTTTGGGG"]
+    >>> quals = ["IIIIIIII", "JJJJJJJJ"]
+    >>> def idx_2_1(Seq, sites, seed): return ([[0,4],[4,8]], [[0,4]])
+    >>> bufF, bufR = processing_cover("readC", seqs, quals, [], 0, idx_2_1, tags="o")
+    >>> len(bufF), len(bufR)
+    (2, 2)
+    >>> any("readC:[F1,R1:FT2,RT1]\\n" in x for x in bufF)
+    True
+    >>> any("readC:[F2,R1:FT2,RT1]\\n" in x for x in bufF)
+    True
+    """
+    bufferF = []
+    bufferR = []
+
+    cover_pairs = list(
+        create_pairs_cover(Sequence, seed_size, ligation_site_list, indexation)
+    )
+    single_pair = len(cover_pairs) == 1
+
+    for _, tag_i, tag_j, fragA, fragB, tot_for, tot_rev in cover_pairs:
+        header = build_pair_header(
+            raw_name=Name,
+            tag_i=tag_i,
+            tag_j=tag_j,
+            tot_for=tot_for,
+            tot_rev=tot_rev,
+            tags=tags,
+            single_pair=single_pair,
+        )
+
+        frag_for, which_for = fragA
+        seq_f = Sequence[which_for][frag_for[0] : frag_for[1]]
+        qual_f = Quality[which_for][frag_for[0] : frag_for[1]]
+        bufferF.append(f"{header}\n{seq_f}\n+\n{qual_f}\n")
+
+        frag_rev, which_rev = fragB
+        seq_r = Sequence[which_rev][frag_rev[0] : frag_rev[1]]
+        qual_r = Quality[which_rev][frag_rev[0] : frag_rev[1]]
+        bufferR.append(f"{header}\n{seq_r}\n+\n{qual_r}\n")
+
+    return bufferF, bufferR
+
+
+################################ Common #####################################
+def process_items(
+    Input_Buffer,
+    Output_buffer,
+    ligation_site_list,
+    seed_size,
+    buffer_size,
+    mode,
+    borderless,
+    tags,
+):
+    """
+    _summary_ : Process the sequences to generate FastQ sequences paired
+    """
+    BigBufferF = []
+    BigBufferR = []
+
+    if borderless:
+        indexation = index_list_borderless
+    else:
+        indexation = index_list
+
+    if mode == "all":
+        Treatment = processing_all
+    elif mode == "fr":
+        Treatment = processing_fr
+    else:
+        Treatment = processing_cover
+
+    while True:
+        try:
+            Items = Input_Buffer.get()
+            if Items is None:
+                break
+
+            for item in Items:
+                # Run the synchronous processing in a separate process
+                bufferF, bufferR = Treatment(
+                    item[0][0],
+                    item[1],
+                    item[2],
+                    ligation_site_list,
+                    seed_size,
+                    indexation,
+                    tags,
+                )
+
+                BigBufferF.extend(bufferF)
+                BigBufferR.extend(bufferR)
+
+                if len(BigBufferF) > buffer_size:
+                    Output_buffer.put([BigBufferF, BigBufferR])
+                    BigBufferF = []
+                    BigBufferR = []
+
+        except Exception as e:
+            logging.exception(f"Error in process items : {e}")
+            raise
+
+    if BigBufferF or BigBufferR:
+        Output_buffer.put([BigBufferF, BigBufferR])
+    Output_buffer.put(None)

split3c/resite/header.py

@@ -0,0 +1,91 @@
+"""
+This script is a the split3c project, designed to process paired-end FASTQ files by fragmenting DNA sequences at specified restriction enzyme sites.
+
+Copyright © 2024 Samir Bertache
+
+SPDX-License-Identifier: AGPL-3.0-or-later
+
+===============================================================================
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU Affero General Public License as published by the
+Free Software Foundation, either version 3 of the License, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+See the GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+
+
+def _tag_from_global_index(k: int, n_for: int) -> str:
+    # k est l’index dans AllFrag = for + rev
+    if k < n_for:
+        return f"F{k + 1}"
+    return f"R{k - n_for + 1}"
+
+
+def _base_name(raw_name: str) -> str:
+    return raw_name.split(" ")[0]
+
+
+def read_name(
+    base_name: str,
+    tag_i: str,
+    tag_j: str,
+    tot_for: int,
+    tot_rev: int,
+    tags: str | None = None,
+) -> str:
+    if tags in ("no_tag", "nt"):
+        return base_name
+    return f"{base_name}:[{tag_i},{tag_j}:FT{tot_for},RT{tot_rev}]"
+
+
+def build_pair_header(
+    raw_name: str,
+    tag_i: str,
+    tag_j: str,
+    tot_for: int,
+    tot_rev: int,
+    tags: str | None,
+    single_pair: bool,
+) -> str:
+    """
+    Contract:
+    - single_pair=True -> base only (strip comments after first space)
+    - tags=None defaults to "o"
+    - tags in ("nt","no_tag","na","no_annot") -> base only
+    - otherwise -> base:[tag_i,tag_j:FTx,RTy]
+
+    >>> build_pair_header("readX", "F1", "R1", 1, 1, tags="o", single_pair=True)
+    'readX'
+    >>> build_pair_header("readX comment blah", "F1", "R1", 1, 1, tags="o", single_pair=True)
+    'readX'
+
+    >>> build_pair_header("readX", "F1", "R1", 1, 1, tags=None, single_pair=False)
+    'readX:[F1,R1:FT1,RT1]'
+    >>> build_pair_header("readX", "F1", "R1", 1, 1, tags="o", single_pair=False)
+    'readX:[F1,R1:FT1,RT1]'
+
+    >>> build_pair_header("readX", "F1", "R1", 1, 1, tags="na", single_pair=False)
+    'readX'
+    >>> build_pair_header("readX", "F1", "R1", 1, 1, tags="no_tag", single_pair=False)
+    'readX'
+    >>> build_pair_header("readX", "F1", "R1", 1, 1, tags="na", single_pair=False)
+    'readX'
+    """
+
+    base = _base_name(raw_name)
+
+    if single_pair:
+        return base
+    if tags is None:
+        tags = "o"
+    if tags in ("no_annot", "na"):
+        return base
+    return read_name(base, tag_i, tag_j, tot_for, tot_rev, tags=tags)