split3c 0.0.1__py3-none-any.whl

split3c/nssite/main.py

@@ -0,0 +1,368 @@
+"""
+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 argparse
+import logging
+import os
+import sys
+from typing import Any, Optional
+
+from .split import cut
+
+__version__ = "1.1.0"
+
+
+def _try_rich() -> Optional[dict[str, Any]]:
+    try:
+        from rich import box
+        from rich.console import Console
+        from rich.panel import Panel
+        from rich.table import Table
+        from rich.theme import Theme
+        from rich.traceback import install
+        from rich_argparse import RichHelpFormatter
+    except Exception:
+        return None
+
+    console = Console(
+        theme=Theme({"info": "dim cyan", "error": "bold red", "warning": "magenta"}),
+        width=100,
+    )
+    install(console=console)
+    return {
+        "console": console,
+        "Panel": Panel,
+        "Table": Table,
+        "box": box,
+        "RichHelpFormatter": RichHelpFormatter,
+    }
+
+
+_R = _try_rich()
+
+
+class MyArgumentParser(argparse.ArgumentParser):
+    def error(self, message: str) -> None:
+        if _R is not None:
+            console = _R["console"]
+            Panel = _R["Panel"]
+            console.print(
+                Panel(
+                    f"[bold red]Error:[/bold red] {message}",
+                    title="Incorrect arguments",
+                    expand=True,
+                    width=100,
+                )
+            )
+            self.print_help()
+            self.exit(2)
+        self.print_usage(sys.stderr)
+        self.exit(2, f"{self.prog}: error: {message}\n")
+
+
+def validate_args(args: argparse.Namespace) -> None:
+    def _file_exists(path: str, what: str) -> None:
+        if not os.path.exists(path):
+            raise ValueError(f"{what}: file not found: {path}")
+        if not os.path.isfile(path):
+            raise ValueError(f"{what}: not a file: {path}")
+
+    def _parent_writable(path: str, what: str) -> None:
+        parent = os.path.dirname(os.path.abspath(path)) or os.getcwd()
+        if not os.path.exists(parent):
+            raise ValueError(f"{what}: parent directory does not exist: {parent}")
+        if not os.access(parent, os.W_OK):
+            raise ValueError(f"{what}: parent directory not writable: {parent}")
+
+    _file_exists(args.bam_1, "Input BAM")
+
+    if not args.single_bam:
+        if args.bam_2 is None:
+            raise ValueError("--bam-2 is required unless --single-bam is used")
+        _file_exists(args.bam_2, "Reverse BAM")
+
+    _parent_writable(args.output_forward, "Output R1")
+    _parent_writable(args.output_reverse, "Output R2")
+
+    if args.num_threads < 7:
+        raise ValueError("--num-threads must be >= 7 (recommended >= 12)")
+
+    if args.seed_size < 0:
+        raise ValueError("--seed-size must be >= 0")
+
+    if args.lenght_added < 0:
+        raise ValueError("--length-added must be >= 0")
+
+    if args.pairing_mode not in ("all", "cover"):
+        raise ValueError("--pairing-mode must be one of: all, cover")
+
+    if args.output_forward == args.output_reverse:
+        raise ValueError("Output R1 and R2 must be different files")
+
+    if not args.force:
+        for p in (args.output_forward, args.output_reverse):
+            if os.path.exists(p):
+                raise ValueError(
+                    f"Output already exists: {p} (use --force to overwrite)"
+                )
+
+
+def _formatter_class():
+    if _R is None:
+        return argparse.RawTextHelpFormatter
+
+    from rich_argparse import RawTextRichHelpFormatter
+
+    return lambda prog: RawTextRichHelpFormatter(
+        prog,
+        max_help_position=42,
+        width=110,
+    )
+
+
+def _print_banner() -> None:
+    if _R is None:
+        return
+    console = _R["console"]
+    Panel = _R["Panel"]
+    console.print(
+        Panel(
+            "[bold blue]Microsplit[/bold blue]\n"
+            "Process paired BAM (Micro-C) into paired FASTQ.\n\n"
+            "Use --help to see detailed options.",
+            title="[bold green]microsplit-cut[/bold green]",
+            subtitle=f"Version: {__version__}",
+            expand=True,
+            width=100,
+        )
+    )
+    console.print("")
+
+
+def _print_summary(args: argparse.Namespace) -> None:
+    if _R is None:
+        return
+    console = _R["console"]
+    Table = _R["Table"]
+    box = _R["box"]
+
+    t = Table(
+        show_edge=True,
+        title="[bold green]Summary[/bold green]",
+        box=box.HEAVY,
+        width=100,
+    )
+    t.add_column("Key", style="cyan", no_wrap=True)
+    t.add_column("Value", style="magenta")
+
+    t.add_row("--single-bam", str(args.single_bam))
+    t.add_row("--bam-1", str(args.bam_1))
+    t.add_row("--bam-2", str(args.bam_2))
+    t.add_row("--output-forward", str(args.output_forward))
+    t.add_row("--output-reverse", str(args.output_reverse))
+    t.add_row("--num-threads", str(args.num_threads))
+    t.add_row("--seed-size", str(args.seed_size))
+    t.add_row("--length-added", str(args.lenght_added))
+    t.add_row("--pairing-mode", str(args.pairing_mode))
+    t.add_row("--tags", str(args.tags))
+    t.add_row("--force", str(args.force))
+    t.add_row("--verbose", str(args.verbose))
+
+    console.print(t)
+    console.print("")
+
+
+def main_cli(argv: Optional[list[str]] = None) -> int:
+    _print_banner()
+
+    parser = MyArgumentParser(
+        description=(
+            "Process Micro-C BAM input to paired FASTQ.\n"
+            "Supports either two BAM files (forward/reverse) or one interleaved BAM."
+        ),
+        epilog=(
+            "Examples:\n"
+            " \tmicrosplit -1 fwd.bam -2 rev.bam -o1 R1.fastq.gz -o2 R2.fastq.gz -t 12 -s 20 -l 0 --pairing-mode cover \n"
+            "  \tmicrosplit -1 merged.bam --single-bam -o1 R1.fastq.gz -o2 R2.fastq.gz -t 12 -s 20 --pairing-mode all\n"
+        ),
+        formatter_class=_formatter_class(),
+    )
+
+    req = parser.add_argument_group("Required inputs")
+    out = parser.add_argument_group("Outputs")
+    perf = parser.add_argument_group("Performance")
+    split = parser.add_argument_group("Split parameters")
+    misc = parser.add_argument_group("Misc")
+
+    req.add_argument(
+        "-1",
+        "--bam_1",
+        type=str,
+        required=True,
+        help="Path to forward BAM file, or to the single interleaved BAM if --single-bam is used.",
+    )
+    req.add_argument(
+        "-2",
+        "--bam_2",
+        type=str,
+        required=False,
+        default=None,
+        help="Path to reverse BAM file. Not required if --single-bam is used.",
+    )
+    req.add_argument(
+        "--single-bam",
+        action="store_true",
+        help="Use a single interleaved BAM as input (R1 line followed by R2 line with same read name).",
+    )
+
+    out.add_argument(
+        "-o1",
+        "--output_forward",
+        type=str,
+        required=True,
+        help="Path to output forward FASTQ (R1).",
+    )
+    out.add_argument(
+        "-o2",
+        "--output_reverse",
+        type=str,
+        required=True,
+        help="Path to output reverse FASTQ (R2).",
+    )
+    out.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite output files if they already exist.",
+    )
+
+    perf.add_argument(
+        "-t",
+        "--num_threads",
+        type=int,
+        default=12,
+        help="Total CPU threads budget (>= 7).",
+    )
+
+    split.add_argument(
+        "-s",
+        "--seed_size",
+        type=int,
+        default=20,
+        help="Minimum fragment length to keep after splitting (0 disables filtering). We strongly advise against using a seed size of less than 10bp for the rest of the treatment (long computing time).",
+    )
+
+    split.add_argument(
+        "-l",
+        "--lenght_added",
+        "--length-added",
+        dest="lenght_added",
+        type=int,
+        default=0,
+        help="Bases added around split boundary (soft-clip extension).",
+    )
+
+    split.add_argument(
+        "--pairing-mode",
+        choices=["all", "cover"],
+        default="cover",
+        help=(
+            "Pair generation strategy.\n"
+            "  cover: minimal/quasi-minimal number of pairs so each fragment appears at least once (Doesn't lose data and is optimal for computation time).\n"
+            "  all: all pairwise combinations."
+        ),
+    )
+
+    split.add_argument(
+        "--tags",
+        choices=["origin", "no_annot", "o", "na"],
+        default="o",
+        help=(
+            "Header tagging mode for split reads.\n"
+            "  origin/o : include fragment origin tags (F0,R1,...)\n"
+            "  no_annot/na: keep base name only / No annotation (Not recommended if you wish to filter the pairs after the process.)"
+        ),
+    )
+
+    misc.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    misc.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        help="Increase verbosity (-v, -vv).",
+    )
+
+    args = parser.parse_args(argv)
+
+    level = logging.WARNING
+    if args.verbose == 1:
+        level = logging.INFO
+    elif args.verbose >= 2:
+        level = logging.DEBUG
+    logging.basicConfig(level=level, format="%(levelname)s: %(message)s")
+
+    try:
+        validate_args(args)
+    except ValueError as e:
+        if _R is not None:
+            Panel = _R["Panel"]
+            _R["console"].print(
+                Panel(
+                    f"[bold red]{e}[/bold red]",
+                    title="Validation",
+                    expand=True,
+                    width=100,
+                )
+            )
+            parser.print_help()
+        else:
+            print(f"ERROR: {e}", file=sys.stderr)
+            parser.print_help(sys.stderr)
+        return 2
+
+    _print_summary(args)
+
+    try:
+        cut(args)
+    except KeyboardInterrupt:
+        return 130
+    except Exception as e:
+        if _R is not None:
+            Panel = _R["Panel"]
+            _R["console"].print(
+                Panel(
+                    f"[bold red]{e}[/bold red]",
+                    title="Runtime error",
+                    expand=True,
+                    width=100,
+                )
+            )
+        else:
+            print(f"ERROR: {e}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    main_cli()

split3c/nssite/processmanager.py

@@ -0,0 +1,51 @@
+from multiprocessing import Process, Queue
+import sys
+import traceback
+
+class WorkerProcess(Process):
+    def __init__(self, target, args, error_queue):
+        super().__init__(target=target, args=args)
+        self.error_queue = error_queue
+
+    def run(self):
+        try:
+            super().run()
+        except Exception as e:
+            print(f"Worker error: {e}")
+            self.error_queue.put((str(e), traceback.format_exc()))
+            sys.exit(1)
+
+class ProcessManager:
+    def __init__(self):
+        self.processes = []
+        self.error_queue = Queue()
+
+    def start_worker(self, target, args):
+        self.processes.append(WorkerProcess(target, args, self.error_queue))
+        self.processes[-1].start()
+
+    def running(self):
+        return any([p.is_alive() for p in self.processes])
+
+    def check_processes(self):
+        for p in self.processes:
+            if not p.is_alive() and p.exitcode != 0:
+                print("Worker process crashed!")
+                return False
+
+        if not self.error_queue.empty():
+            error, tb = self.error_queue.get()
+            print(f"Worker error: {error}")
+            self.shutdown()
+        return True
+
+    def shutdown(self):
+        for i, p in enumerate(self.processes):
+            if p.is_alive():
+                p.terminate()
+                p.join()
+
+    def handle_signal(self, signum, frame):
+        print("Received shutdown signal")
+        self.shutdown()
+        sys.exit(1)