coralsnake 0.0.1__tar.gz

coralsnake-0.0.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: coralsnake
+Version: 0.0.1
+Summary: 
+Author: Chang Ye
+Author-email: yech1990@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: dnaio (>=1.2.1,<2.0.0)
+Requires-Dist: pyfaidx (>=0.8.1.1,<0.9.0.0)
+Requires-Dist: rich-click (>=1.8.3,<2.0.0)
+Description-Content-Type: text/markdown
+
+# Coralsnake
+
+

coralsnake-0.0.1/README.md

@@ -0,0 +1,2 @@
+# Coralsnake
+

coralsnake-0.0.1/build.py

@@ -0,0 +1,108 @@
+import os
+import platform
+import shutil
+from distutils.command.build_ext import build_ext
+from distutils.core import Distribution, Extension
+
+from Cython.Build import cythonize
+
+# Define the base path for minimap2 sources
+minimap2_base = "coralsnake/minimap2"
+
+# Define extra compile arguments based on the platform
+extra_compile_args = ["-DHAVE_KALLOC", "-O3"]
+include_dirs = [minimap2_base]
+
+# Adjust compile args for ARM or x86 architectures
+if platform.machine() in ["aarch64", "arm64"]:
+    include_dirs.append(os.path.join(minimap2_base, "sse2neon"))
+    extra_compile_args.extend(["-ftree-vectorize", "-DKSW_SSE2_ONLY", "-D__SSE2__"])
+else:
+    extra_compile_args.append("-msse4.1")  # Note: ancient x86_64 CPUs don't have SSE4
+
+libraries = ["z", "m", "pthread"]
+
+
+def build():
+    sources = [
+        "python/mappy.pyx",
+        "align.c",
+        "bseq.c",
+        "lchain.c",
+        "seed.c",
+        "format.c",
+        "hit.c",
+        "index.c",
+        "pe.c",
+        "options.c",
+        "ksw2_extd2_sse.c",
+        "ksw2_exts2_sse.c",
+        "ksw2_extz2_sse.c",
+        "ksw2_ll_sse.c",
+        "kalloc.c",
+        "kthread.c",
+        "map.c",
+        "misc.c",
+        "sdust.c",
+        "sketch.c",
+        "esterr.c",
+        "splitidx.c",
+    ]
+    depends = [
+        "minimap.h",
+        "bseq.h",
+        "kalloc.h",
+        "kdq.h",
+        "khash.h",
+        "kseq.h",
+        "ksort.h",
+        "ksw2.h",
+        "kthread.h",
+        "kvec.h",
+        "mmpriv.h",
+        "sdust.h",
+        "python/cmappy.h",
+        "python/cmappy.pxd",
+    ]
+    sources = [os.path.join(minimap2_base, file) for file in sources]
+    depends = [os.path.join(minimap2_base, file) for file in depends]
+
+    extensions = [
+        Extension(
+            "mappy",
+            sources=sources,
+            depends=depends,
+            extra_compile_args=extra_compile_args,
+            include_dirs=include_dirs,
+            libraries=libraries,
+        )
+    ]
+    ext_modules = cythonize(
+        extensions,
+        include_path=include_dirs,
+        compiler_directives={"binding": True, "language_level": 3},
+    )
+
+    distribution = Distribution({"name": "coralsnake", "ext_modules": ext_modules})
+    distribution.package_dir = "coralsnake"
+
+    # Define the output directory for the compiled extensions
+    output_dir = "coralsnake"
+    cmd = build_ext(distribution)
+    cmd.build_lib = output_dir  # Direct output to coralsnake directory
+    cmd.ensure_finalized()
+    cmd.run()
+
+    # Ensure the outputs are set with the correct permissions
+    for output in cmd.get_outputs():
+        # relative_extension = os.path.relpath(output, cmd.build_lib)
+        # shutil.copyfile(output, relative_extension)
+        mode = os.stat(output).st_mode
+        mode |= (
+            mode & 0o444
+        ) >> 2  # Make read-only by owner readable by group and others
+        os.chmod(output, mode)
+
+
+if __name__ == "__main__":
+    build()

coralsnake-0.0.1/coralsnake/.gitignore

@@ -0,0 +1 @@
+mappy.*.so

coralsnake-0.0.1/coralsnake/cli.py

@@ -0,0 +1,148 @@
+import rich_click as click
+
+
+@click.group(
+    invoke_without_command=False,
+    help="Variant (genomic variant analysis in python)",
+    context_settings=dict(help_option_names=["-h", "--help"]),
+)
+@click.version_option(None, "-v", "--version")
+@click.pass_context
+def cli(ctx):
+    pass
+
+
+@cli.command(
+    help="Extract primary transcript from gtf/gff file.",
+    no_args_is_help=True,
+    context_settings=dict(help_option_names=["-h", "--help"]),
+)
+@click.option(
+    "--gtf-file",
+    "-g",
+    "gtf_file",
+    help="GTF file.",
+    required=True,
+)
+@click.option(
+    "--fasta-file",
+    "-f",
+    "fasta_file",
+    help="Fasta file.",
+    required=True,
+)
+@click.option(
+    "--output-file",
+    "-o",
+    "output_file",
+    help="Output file.",
+    required=True,
+)
+@click.option(
+    "--seq-file",
+    "-s",
+    "seq_file",
+    help="Sequence file.",
+    required=True,
+)
+def extract(gtf_file, fasta_file, output_file, seq_file):
+    from .gtf2tx import parse_file
+
+    parse_file(gtf_file, fasta_file, output_file, seq_file)
+
+
+@cli.command(
+    help="Fetch genomic motif.",
+    no_args_is_help=True,
+    context_settings=dict(help_option_names=["-h", "--help"]),
+)
+@click.option(
+    "--input",
+    "-i",
+    "input",
+    default="-",
+    help="Input position file.",
+    required=False,
+)
+@click.option(
+    "--output",
+    "-o",
+    "output",
+    default="-",
+    help="Output annotation file.",
+    required=False,
+)
+@click.option(
+    "--fasta",
+    "-f",
+    "fasta",
+    help="reference fasta file.",
+    required=True,
+)
+@click.option(
+    "--npad",
+    "-n",
+    "npad",
+    default="10",
+    help="Number of padding base to call motif. "
+    "If you want to set different left and right pads, "
+    "use comma to separate them. (eg. 2,3)",
+)
+@click.option(
+    "--with-header", "-H", help="With header line in input file.", is_flag=True
+)
+@click.option(
+    "--columns",
+    "-c",
+    "columns",
+    default="1,2,3",
+    show_default=True,
+    type=str,
+    help="Sets columns for site info. (Chrom,Pos,Strand)",
+)
+@click.option("--to-upper", "-u", help="Convert motif to upper case.", is_flag=True)
+@click.option("--wrap-site", "-w", help="Wrap motif site.", is_flag=True)
+def motif(input, output, fasta, npad, with_header, columns, to_upper, wrap_site):
+    from .motif import run_motif
+
+    if "," in npad:
+        lpad, rpad = npad.split(",")
+    else:
+        lpad, rpad = npad, npad
+    # check if lpad and rpad are positive int
+    # exit with error if not
+    if not lpad.isdigit() or not rpad.isdigit():
+        click.echo(f"Error: npad should be positive integer, not {npad}", err=True)
+        exit(1)
+    lpad = int(lpad)
+    rpad = int(rpad)
+    run_motif(
+        input,
+        output,
+        fasta,
+        lpad,
+        rpad,
+        with_header,
+        columns,
+        to_upper,
+        wrap_site,
+    )
+
+
+@cli.command(
+    help="Map reads to reference genome.",
+    no_args_is_help=True,
+    context_settings=dict(help_option_names=["-h", "--help"]),
+)
+@click.option("-r", "--ref-file", help="reference file", required=True)
+@click.option("-1", "--r1-file", help="r1 file", required=True)
+@click.option("-2", "--r2-file", help="r2 file", required=True)
+@click.option("-f", "--fwd-lib", is_flag=True, help="forward library")
+def map(ref_file, r1_file, r2_file, fwd_lib):
+    from .mapping import map_file
+
+    map_file(ref_file, r1_file, r2_file, fwd_lib)
+
+
+if __name__ == "__main__":
+    cli()

coralsnake-0.0.1/coralsnake/conversion.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright © 2023 Ye Chang yech1990@gmail.com
+# Distributed under terms of the GNU license.
+#
+# Created: 2023-01-30 15:55
+
+"""convert A->G, C->T in DNA sequence."""
+
+import sys
+
+import dnaio
+
+MK_BASE_MAPPER = str.maketrans("ACGTacgt", "GTGTgtgt")
+KM_BASE_MAPPER = str.maketrans("ACGTacgt", "ACACacac")
+
+
+def mk_conversion(seq):
+    return seq.translate(MK_BASE_MAPPER)
+
+
+def km_conversion(seq):
+    return seq.translate(KM_BASE_MAPPER)
+
+
+def convert_file(input_file, output_MK_file, output_KM_file):
+    with dnaio.open(input_file, mode="r") as fi, dnaio.open(
+        output_MK_file, mode="w"
+    ) as fo_mk, dnaio.open(output_KM_file, mode="w") as fo_km:
+        for read in fi:
+            n = read.name.split()[0]
+            n_mk = f"{n} YS:Z:{read.sequence}\tST:A:+"
+            r_mk = dnaio.SequenceRecord(
+                name=n_mk,
+                sequence=mk_conversion(read.sequence),
+                qualities=read.qualities,
+            )
+            fo_mk.write(r_mk)
+
+            n_km = f"{n} YS:Z:{read.sequence}\tST:A:-"
+            r_km = dnaio.SequenceRecord(
+                name=n_km,
+                sequence=km_conversion(read.sequence),
+                qualities=read.qualities,
+            )
+            fo_km.write(r_km)

coralsnake-0.0.1/coralsnake/debug.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright © 2024 Ye Chang yech1990@gmail.com
+# Distributed under terms of the GNU license.
+#
+# Created: 2024-06-08 20:32
+
+
+import os
+
+import mappy as mp
+
+# on forward strand example
+seq1 = "TCGGGTTGCTTGGGAATGCAGCCCAAAGCGGGT"
+seq2 = "AGTTTACCACCCGCTTTGGGCTGCATTCCCAAGCA"
+
+idx = mp.Aligner(fn_idx_in="./debug.fa", preset="sr")
+
+# q_st  q_en  strand  ctg  ctg_len  r_st  r_en  mlen  blen  mapq  cg:Z:cigar_str
+
+for hit in idx.map(seq1, seq2=seq2, cs=True, MD=True):
+    print(str(hit))
+print(".......")
+
+# reverse
+for hit in idx.map(seq1, seq2=seq2[::-1], cs=True, MD=True):
+    print(str(hit))
+print(".......")
+
+# complement
+for hit in idx.map(seq1, seq2=mp.revcomp(seq2)[::-1], cs=True, MD=True):
+    print(str(hit))
+print(".......")
+
+# rev complement complement
+for hit in idx.map(seq1, seq2=mp.revcomp(seq2), cs=True, MD=True):
+    print(str(hit))
+print(".......")

coralsnake-0.0.1/coralsnake/gtf2tx.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright © 2024 Ye Chang yech1990@gmail.com
+# Distributed under terms of the GNU license.
+#
+# Created: 2024-05-01 18:23
+
+
+import logging
+from collections import defaultdict
+
+from pyfaidx import Fasta
+from rich.progress import track
+
+logging.basicConfig(level=logging.INFO)
+
+
+class TranscriptExon:
+    def __init__(self, chrom=None, strand=None, gene_id=None, gene_name=None):
+        self.gene_id = gene_id
+        self.gene_name = gene_name
+        self.chrom = chrom
+        self.strand = strand
+        self.span = {}
+        self.priority = (10, 0)
+
+    def add_span(self, gene_id, gene_name, chrom, strand, exon_number, start, end):
+        self.gene_id = gene_id
+        self.gene_name = gene_name
+        if self.chrom is not None and self.chrom != chrom:
+            raise ValueError("Chrom mismatch")
+        self.chrom = chrom
+        self.strand = strand
+        self.span[exon_number] = (start, end)
+
+    def calc_len(self):
+        return sum([v[1] - v[0] + 1 for _, v in self.span.items()])
+
+    def get_seq(self, fasta):
+        seq = ""
+        for _, v in sorted(self.span.items()):
+            e = fasta[self.chrom][v[0] - 1 : v[1]]
+            if self.strand == "-":
+                e = e.reverse.complement
+            seq += e.seq
+        return seq.upper()
+
+    def __repr__(self):
+        # sort the exon number
+        # span_str = ",".join([f"{v[0]}-{v[1]}" for _, v in sorted(self.span.items())])
+        # do not sort the exon number
+        span_str = ",".join([f"{v[0]}-{v[1]}" for v in self.span.values()])
+        gene_name = "." if self.gene_name is None else self.gene_name
+        return f"{gene_name}\t{self.chrom}\t{self.strand}\t{span_str}"
+
+
+def parse_gtf_annot(annot):
+    annot = annot.rstrip("\n").rstrip(";").split("; ")
+    annot = [x.strip().split(" ", 1) for x in annot if x]
+    # if the key is duplicate, join the values
+    d = defaultdict(list)
+    for k, v in annot:
+        d[k].append(v.strip('"'))
+
+    return {k: "; ".join(v) for k, v in d.items()}
+
+
+def parse_gff_annot(annot):
+    annot = annot.rstrip("\n").rstrip(";").split(";")
+    annot = [x.strip().split("=", 1) for x in annot if x]
+    # assume gff is unique
+    return {k: v for k, v in annot}
+
+
+def read_gtf(gtf_file, is_gff=False):
+    if is_gff:
+        parse_annot = parse_gff_annot
+    else:
+        parse_annot = parse_gtf_annot
+    gene_dict = defaultdict(lambda: defaultdict(lambda: TranscriptExon()))
+
+    # i = 0
+    with open(gtf_file, "r") as f:
+        for line in track(f, description="Parsing GTF..."):
+            # i += 1
+            # if i % 200_000 == 0:
+            #     logging.info(f"Processed {i:,} lines")
+            if line.startswith("#"):
+                continue
+            line = line.strip().split("\t")
+            if len(line) < 9 or line[2] != "exon":
+                continue
+            d = parse_annot(line[8])
+            if "gene_id" in d and "transcript_id" in d:
+                gene_id = d["gene_id"]
+                transcript_id = d["transcript_id"]
+                exon_id = d["exon_number"] if "exon_number" in d else d["exon"]
+            elif "Parent" in d and "ID" in d:
+                gene_id = d["Parent"]
+                transcript_id, exon_id = d["ID"].rsplit(".", 1)
+                exon_id = exon_id.removeprefix("exon")
+            else:
+                continue
+            # if exon id is digit, convert to interger
+            if exon_id.isdigit():
+                exon_id = int(exon_id)
+            if "tag" in d:
+                tags = d["tag"].split("; ")
+                if "MANE_Select" in tags:
+                    priority = (0, 0)
+                elif "Ensembl_canonical" in tags:
+                    priority = (0, 1)
+                elif "basic" in tags:
+                    priority = (0, 2)
+                else:
+                    priority = (10, 0)
+            elif (
+                "transcript_support_level" in d
+                and (sl := d.get("transcript_support_level", "").split()[0]).isdigit()
+            ):
+                priority = (1, int(sl))
+            else:
+                priority = (10, 0)
+            gene_dict[gene_id][transcript_id].priority = priority
+            gene_dict[gene_id][transcript_id].add_span(
+                gene_id,
+                d.get("gene_name", None),
+                line[0],
+                line[6],
+                exon_id,
+                int(line[3]),
+                int(line[4]),
+            )
+    return gene_dict
+
+
+def rank_exons(tx_id, exon_info):
+    # level 0, MANE_Select, highest priority
+    # level 1, transcript_support_level, smaller level will have higher priority
+    # level 10 (default), others, lowest priority
+    # patched:
+    # level 2, tx_id with ".1", ".2", .. suffix, smaller number will have higher priority
+    # level 3, tx_id with "-01", "-02", .. suffix, smaller number will have higher priority
+    # level 4, tx_len, longer transcript will have higher priority
+    if exon_info.priority[0] < 10:
+        return exon_info.priority
+    # some plant sample such as Arabidopsis will have ".1", ".2", ... tag in the end of tx_id
+    if "." in tx_id and tx_id.split(".")[-1].isdigit():
+        return (2, int(tx_id.split(".")[-1]))
+    # some plant sample such as rice will have "-01" tag in the end of tx_id
+    if "-" in tx_id and tx_id.split("-")[-1].isdigit():
+        return (3, int(tx_id.split("-")[-1]))
+    # start from 100 to 100,000, longer transcript will have higher priority
+    tx_len = exon_info.calc_len()
+    return (4, 100_100 - tx_len if tx_len < 100_000 else 100_001)
+
+
+def parse_file(gtf_file, fasta_file, output_file, seq_file):
+    gene_dict = read_gtf(
+        gtf_file, is_gff=gtf_file.endswith("gff") or gtf_file.endswith("gff3")
+    )
+    fasta = Fasta(fasta_file, read_ahead=100_000)
+    # i = 0
+    with open(output_file, "w") as f1, open(seq_file, "w") as f2:
+        f1.write("gene_id\ttranscript_id\tgene_name\tchrom\tstrand\tspans\n")
+        for g, v in track(gene_dict.items(), description="Fetching sequences..."):
+            # i += 1
+            # if i % 5_000 == 0:
+            #     logging.info(f"Processed {i:,} genes")
+            vs = sorted(v.items(), key=lambda x: rank_exons(x[0], x[1]))
+            e, v2 = vs[0]
+            f1.write(f"{g}\t{e}\t{v2}\n")
+            f2.write(f">{g}\n{v2.get_seq(fasta)}\n")
+
+
+if __name__ == "__main__":
+    import argparse
+
+    argparser = argparse.ArgumentParser()
+    argparser.add_argument("-g", "--gtf-file", help="GTF file", required=True)
+    argparser.add_argument("-f", "--fasta-file", help="Fasta file", required=True)
+    argparser.add_argument("-o", "--output-file", help="Output file", required=True)
+    argparser.add_argument(
+        "-s", "--seq-file", help="Output sequence file", required=True
+    )
+
+    args = argparser.parse_args()
+    parse_file(args.gtf_file, args.fasta_file, args.output_file, args.seq_file)