babappa 0.1.0__tar.gz

babappa-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: babappa
+Version: 0.1.0
+Summary: Evolutionary selection pipeline integrating RBH, codon alignment, HyPhy, PAML, and ancestral reconstruction.
+Author-email: Krishnendu Sinha <dr.krishnendusinha@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: biopython
+Requires-Dist: snakemake

babappa-0.1.0/babappa/cli.py

@@ -0,0 +1,28 @@
+import argparse
+import subprocess
+from pathlib import Path
+
+def main():
+
+    parser = argparse.ArgumentParser(prog="babappa")
+    parser.add_argument("--query", required=True)
+    parser.add_argument("--proteomes", required=True)
+    parser.add_argument("--cds", required=True)
+    parser.add_argument("--threads", type=int, default=4)
+
+    args = parser.parse_args()
+
+    workflow_dir = Path(__file__).parent / "workflow"
+    snakefile = workflow_dir / "Snakefile"
+
+    cmd = [
+        "snakemake",
+        "-s", str(snakefile),
+        "--cores", str(args.threads),
+        "--config",
+        f"query={args.query}",
+        f"proteomes={args.proteomes}",
+        f"cds={args.cds}"
+    ]
+
+    subprocess.run(cmd, check=True)

babappa-0.1.0/babappa/workflow/scripts/ancestral_reconstruction.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+
+import subprocess
+from pathlib import Path
+import shutil
+import re
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+from Bio import SeqIO
+
+############################################################
+# Snakemake inputs
+############################################################
+
+aln = Path(snakemake.input.aln).resolve()
+tree = Path(snakemake.input.tree).resolve()
+summary = Path(snakemake.input.summary).resolve()
+
+output_fasta = Path(snakemake.output[0]).resolve()
+
+base_dir = output_fasta.parent
+base_dir.mkdir(parents=True, exist_ok=True)
+
+############################################################
+# Read significant branches
+############################################################
+
+significant_branches = []
+
+with open(summary) as f:
+    next(f)
+    for line in f:
+        fields = line.strip().split("\t")
+        branch = fields[0]
+        significant = fields[5]
+        if significant == "YES":
+            significant_branches.append(branch)
+
+if not significant_branches:
+    print("[INFO] No significant branches. No ASR performed.")
+    output_fasta.touch()
+    exit()
+
+print(f"[INFO] Reconstructing ancestors for {len(significant_branches)} branches")
+
+############################################################
+# Utility
+############################################################
+
+def write_ctl(path, seqfile, treefile):
+    content = f"""
+      seqfile = {seqfile}
+      treefile = {treefile}
+      outfile = mlc
+
+      noisy = 0
+      verbose = 0
+      runmode = 0
+
+      seqtype = 1
+      CodonFreq = 2
+
+      model = 0
+      NSsites = 0
+
+      RateAncestor = 1
+      cleandata = 1
+    """
+    path.write_text(content)
+
+
+def extract_ancestral_from_rst(rst_file):
+    sequences = {}
+    capture = False
+
+    with open(rst_file) as f:
+        for line in f:
+            if "List of extant and reconstructed sequences" in line:
+                capture = True
+                continue
+
+            if capture:
+                if line.strip() == "":
+                    break
+
+                parts = line.strip().split()
+                if len(parts) >= 2:
+                    node = parts[0]
+                    seq = parts[1]
+                    sequences[node] = seq
+
+    return sequences
+
+
+############################################################
+# Perform ASR once (not per branch)
+############################################################
+
+workdir = base_dir / "ancestral_tmp"
+workdir.mkdir(exist_ok=True)
+
+shutil.copy(aln, workdir / "aln.phy")
+shutil.copy(tree, workdir / "tree.nwk")
+
+ctl_file = workdir / "asr.ctl"
+write_ctl(ctl_file, "aln.phy", "tree.nwk")
+
+print("[INFO] Running codeml ancestral reconstruction")
+subprocess.run(["codeml", str(ctl_file)], cwd=workdir, check=True)
+
+rst_file = workdir / "rst"
+
+if not rst_file.exists():
+    raise RuntimeError("rst file not generated")
+
+ancestral_sequences = extract_ancestral_from_rst(rst_file)
+
+############################################################
+# Map branches to ancestor node
+############################################################
+
+# Codeml internal nodes are numeric labels (e.g., 8, 9, 10...)
+# We extract the parent node for each branch from the tree
+
+with open(tree) as f:
+    newick = f.read()
+
+records = []
+
+for branch in significant_branches:
+
+    # Find pattern like: (ancestor,branch)
+    pattern = r"\(([^,()]+)," + re.escape(branch) + r"\)"
+    match = re.search(pattern, newick)
+
+    if not match:
+        continue
+
+    ancestor_node = match.group(1)
+
+    if ancestor_node in ancestral_sequences:
+        seq = ancestral_sequences[ancestor_node]
+        protein = Seq(seq).translate()
+
+        records.append(
+            SeqRecord(
+                protein,
+                id=f"Ancestor_of_{branch}",
+                description=""
+            )
+        )
+
+############################################################
+# Write FASTA
+############################################################
+
+if records:
+    SeqIO.write(records, output_fasta, "fasta")
+else:
+    output_fasta.touch()
+
+print("\n[INFO] Ancestral reconstruction completed.\n")

babappa-0.1.0/babappa/workflow/scripts/codon_align.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+
+import subprocess
+from pathlib import Path
+import shutil
+import glob
+
+############################################################
+# Utility
+############################################################
+
+def run_cmd(cmd, cwd=None):
+    print("[RUN]", " ".join(cmd))
+    subprocess.run(cmd, check=True, cwd=cwd)
+
+
+############################################################
+# Snakemake inputs
+############################################################
+
+cds_input = Path(snakemake.input.cds).resolve()
+
+protein_aln_output = Path(snakemake.output.protein_aln).resolve()
+cds_aln_output = Path(snakemake.output.cds_aln).resolve()
+
+threads = snakemake.threads
+
+alignment_dir = protein_aln_output.parent.resolve()
+alignment_dir.mkdir(parents=True, exist_ok=True)
+
+############################################################
+# Copy input CDS into alignment directory
+############################################################
+
+local_cds = alignment_dir / cds_input.name
+shutil.copy(str(cds_input), str(local_cds))
+
+############################################################
+# Run babappalign in alignment directory
+############################################################
+
+print("\n=== RUNNING BABAPPALIGN (CODON MODE) ===")
+
+run_cmd([
+    "babappalign",
+    local_cds.name,
+    "--mode", "codon",
+    "--model", "babappascore"
+], cwd=alignment_dir)
+
+############################################################
+# Detect generated alignment files
+############################################################
+
+print("\n=== DETECTING BABAPPALIGN OUTPUT FILES ===")
+
+fasta_files = list(alignment_dir.glob("*.fasta"))
+
+if len(fasta_files) < 2:
+    raise RuntimeError("Babappalign did not produce expected FASTA outputs.")
+
+codon_file = None
+protein_file = None
+
+for f in fasta_files:
+    name = f.name.lower()
+
+    if "codon" in name:
+        codon_file = f
+    elif "protein" in name or "pep" in name:
+        protein_file = f
+
+# Fallback detection (if names don't contain keywords)
+if codon_file is None or protein_file is None:
+
+    # Identify by sequence alphabet
+    from Bio import SeqIO
+
+    for f in fasta_files:
+        record = next(SeqIO.parse(f, "fasta"))
+        seq = str(record.seq)
+
+        if set(seq.upper()) <= set("ACGTN-"):
+            codon_file = f
+        else:
+            protein_file = f
+
+if codon_file is None or protein_file is None:
+    raise RuntimeError("Could not determine codon vs protein alignment files.")
+
+############################################################
+# Move to final Snakemake outputs
+############################################################
+
+shutil.move(str(codon_file), str(cds_aln_output))
+shutil.move(str(protein_file), str(protein_aln_output))
+
+############################################################
+# Cleanup temporary input copy
+############################################################
+
+local_cds.unlink()
+
+print("\n✅ Codon alignment complete.")

babappa-0.1.0/babappa/workflow/scripts/dynamic_codeml.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+
+import os
+import re
+import math
+import subprocess
+from pathlib import Path
+from scipy.stats import chi2
+
+############################################################
+# Snakemake inputs
+############################################################
+
+alignment = Path(snakemake.input.aln).resolve()
+tree_file = Path(snakemake.input.tree).resolve()
+branches_file = Path(snakemake.input.branches).resolve()
+
+output_flag = Path(snakemake.output[0]).resolve()
+
+results_dir = output_flag.parent
+results_dir.mkdir(parents=True, exist_ok=True)
+
+############################################################
+# Utilities
+############################################################
+
+def run_cmd(cmd, cwd=None):
+    print("[RUN]", " ".join(cmd))
+    subprocess.run(cmd, cwd=cwd, check=True)
+
+
+def extract_lnL(mlc_file):
+    """
+    Robust lnL extraction from PAML mlc file
+    """
+    with open(mlc_file) as f:
+        for line in f:
+            if "lnL" in line:
+                matches = re.findall(r"-?\d+\.\d+", line)
+                if matches:
+                    return float(matches[0])
+    raise RuntimeError(f"lnL not found in {mlc_file}")
+
+
+def extract_beb_sites(mlc_file):
+    """
+    Extract BEB sites with PP >= 0.95
+    """
+    beb_sites = []
+    capture = False
+
+    with open(mlc_file) as f:
+        for line in f:
+            if "Bayes Empirical Bayes" in line:
+                capture = True
+                continue
+
+            if capture:
+                if line.strip() == "":
+                    break
+
+                parts = line.strip().split()
+                if len(parts) >= 3:
+                    try:
+                        site = parts[0]
+                        aa = parts[1]
+                        prob = float(parts[-1].replace("*", ""))
+                        if prob >= 0.95:
+                            beb_sites.append((site, aa, prob))
+                    except:
+                        continue
+
+    return beb_sites
+
+
+def write_ctl(path, seqfile, treefile, outfile, fix_omega):
+    """
+    Write branch-site control file
+    """
+    with open(path, "w") as ctl:
+        ctl.write(f"""
+seqfile = {seqfile}
+treefile = {treefile}
+outfile = {outfile}
+
+noisy = 3
+verbose = 1
+runmode = 0
+
+seqtype = 1
+CodonFreq = 7
+clock = 0
+
+model = 2
+NSsites = 2
+
+icode = 0
+fix_kappa = 0
+kappa = 2
+
+fix_omega = {fix_omega}
+omega = 1.5
+
+fix_alpha = 1
+alpha = 0
+Malpha = 0
+
+ncatG = 4
+getSE = 0
+RateAncestor = 0
+Small_Diff = 1e-6
+        """)
+
+
+############################################################
+# Read foreground branches
+############################################################
+
+with open(branches_file) as f:
+    branches = [line.strip() for line in f if line.strip()]
+
+print(f"[INFO] Running codeml for {len(branches)} foreground branches")
+
+summary_lines = []
+summary_lines.append("Branch\tlnL_null\tlnL_alt\tLRT\tpvalue\tSignificant\tBEB_sites")
+
+############################################################
+# Run codeml per branch
+############################################################
+
+for branch in branches:
+
+    print(f"\n[INFO] Processing branch: {branch}")
+
+    workdir = results_dir / f"codeml_{branch}"
+    workdir.mkdir(exist_ok=True)
+
+    # Create branch-labeled tree
+    tree_text = open(tree_file).read()
+    labeled_tree = tree_text.replace(branch, branch + " #1")
+    labeled_tree_file = workdir / "tree.nwk"
+    labeled_tree_file.write_text(labeled_tree)
+
+    # Copy alignment
+    aln_copy = workdir / "alignment.phy"
+    subprocess.run(["cp", str(alignment), str(aln_copy)], check=True)
+
+    # Write control files
+    alt_ctl = workdir / "alt.ctl"
+    null_ctl = workdir / "null.ctl"
+
+    write_ctl(alt_ctl, aln_copy, labeled_tree_file, "alt.mlc", fix_omega=0)
+    write_ctl(null_ctl, aln_copy, labeled_tree_file, "null.mlc", fix_omega=1)
+
+    try:
+        run_cmd(["codeml", str(null_ctl)], cwd=workdir)
+        run_cmd(["codeml", str(alt_ctl)], cwd=workdir)
+    except subprocess.CalledProcessError:
+        print(f"[WARNING] codeml failed for branch {branch}")
+        continue
+
+    # Extract lnL
+    lnL_null = extract_lnL(workdir / "null.mlc")
+    lnL_alt = extract_lnL(workdir / "alt.mlc")
+
+    # Compute LRT
+    LRT = 2 * (lnL_alt - lnL_null)
+
+    # Mixture chi-square 0.5*χ²₁
+    pvalue = 0.5 * (1 - chi2.cdf(LRT, 1))
+
+    significant = "YES" if pvalue <= 0.05 else "NO"
+
+    beb_sites = extract_beb_sites(workdir / "alt.mlc")
+
+    beb_string = ";".join([f"{s}:{a}:{p:.3f}" for s,a,p in beb_sites])
+
+    summary_lines.append(
+        f"{branch}\t{lnL_null:.6f}\t{lnL_alt:.6f}\t{LRT:.4f}\t{pvalue:.6f}\t{significant}\t{beb_string}"
+    )
+
+############################################################
+# Write summary
+############################################################
+
+summary_file = results_dir / "codeml_branch_site_summary.tsv"
+
+with open(summary_file, "w") as f:
+    f.write("\n".join(summary_lines))
+
+print(f"\n[INFO] Summary written to {summary_file}")
+
+# Touch done flag
+output_flag.touch()
+
+print("\n✅ Dynamic codeml complete.\n")

babappa-0.1.0/babappa/workflow/scripts/orthogroup.py

@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+
+import subprocess
+from pathlib import Path
+from Bio import SeqIO
+from Bio.SeqRecord import SeqRecord
+
+############################################################
+# Utility
+############################################################
+
+def run_cmd(cmd, cwd=None):
+    print("[RUN]", " ".join(cmd))
+    subprocess.run(cmd, check=True, cwd=cwd)
+
+
+def make_blast_db(fasta, dbtype, db_dir):
+    fasta = Path(fasta).resolve()
+    db_dir = Path(db_dir).resolve()
+    db_dir.mkdir(parents=True, exist_ok=True)
+
+    prefix = db_dir / fasta.stem
+    index_file = prefix.with_suffix(".nin" if dbtype == "nucl" else ".pin")
+
+    if not index_file.exists():
+        run_cmd([
+            "makeblastdb",
+            "-in", str(fasta),
+            "-dbtype", dbtype,
+            "-out", str(prefix)
+        ])
+
+    return str(prefix)
+
+
+############################################################
+# Snakemake Inputs
+############################################################
+
+query_file = Path(snakemake.input.query).resolve()
+proteome_dir = Path(snakemake.input.proteomes).resolve()
+cds_dir = Path(snakemake.input.cds).resolve()
+
+protein_output = Path(snakemake.output.proteins).resolve()
+cds_output = Path(snakemake.output.cds).resolve()
+
+threads = snakemake.threads
+
+min_cov = 0.7
+evalue_cutoff = 1e-5
+identity_threshold = 99.0
+
+results_dir = protein_output.parent
+blast_db_dir = results_dir / "blastdb"
+
+results_dir.mkdir(parents=True, exist_ok=True)
+
+############################################################
+# RBH STAGE
+############################################################
+
+print("\n=== RBH STAGE ===")
+
+query_record = next(SeqIO.parse(query_file, "fasta"))
+query_id = query_record.id
+
+query_db = make_blast_db(query_file, "prot", blast_db_dir)
+
+orthogroup_proteins = []
+
+for species_path in proteome_dir.glob("*"):
+
+    if species_path.suffix not in [".faa", ".fa", ".fasta"]:
+        continue
+
+    species_path = species_path.resolve()
+    species_name = species_path.stem
+
+    print(f"[INFO] Processing {species_name}")
+
+    species_db = make_blast_db(species_path, "prot", blast_db_dir)
+
+    fwd_out = results_dir / f"{species_name}_fwd.tsv"
+    rev_out = results_dir / f"{species_name}_rev.tsv"
+
+    run_cmd([
+        "blastp",
+        "-query", str(query_file),
+        "-db", species_db,
+        "-out", str(fwd_out),
+        "-evalue", str(evalue_cutoff),
+        "-outfmt", "6 qseqid sseqid pident length qlen slen bitscore",
+        "-num_threads", str(threads)
+    ])
+
+    run_cmd([
+        "blastp",
+        "-query", str(species_path),
+        "-db", query_db,
+        "-out", str(rev_out),
+        "-evalue", str(evalue_cutoff),
+        "-outfmt", "6 qseqid sseqid pident length qlen slen bitscore",
+        "-num_threads", str(threads)
+    ])
+
+    def get_best_hits(blast_file):
+        best = {}
+        with open(blast_file) as f:
+            for line in f:
+                q, s, pident, length, qlen, slen, bitscore = line.strip().split()
+                length, qlen, slen = int(length), int(qlen), int(slen)
+                bitscore = float(bitscore)
+
+                if (length/qlen) >= min_cov and (length/slen) >= min_cov:
+                    if q not in best or bitscore > best[q][1]:
+                        best[q] = (s, bitscore)
+        return {q: s for q, (s, _) in best.items()}
+
+    fwd_hits = get_best_hits(fwd_out)
+    rev_hits = get_best_hits(rev_out)
+
+    rbh = {q: s for q, s in fwd_hits.items()
+           if s in rev_hits and rev_hits[s] == q}
+
+    if query_id not in rbh:
+        print(f"[WARN] No RBH for {species_name}")
+        continue
+
+    ortholog_id = rbh[query_id]
+
+    for record in SeqIO.parse(species_path, "fasta"):
+        if record.id == ortholog_id:
+            orthogroup_proteins.append(record)
+            break
+
+SeqIO.write(orthogroup_proteins, protein_output, "fasta")
+print(f"[INFO] Protein orthogroup written: {protein_output}")
+
+############################################################
+# MERGE TRANSCRIPTS INTO RESULTS
+############################################################
+
+print("\n=== MERGING TRANSCRIPTS ===")
+
+merged_transcripts = results_dir / "all_transcripts.fasta"
+
+with open(merged_transcripts, "w") as out:
+    for file in cds_dir.glob("*"):
+        if file.suffix in [".fa", ".fasta", ".fna"]:
+            for record in SeqIO.parse(file, "fasta"):
+                SeqIO.write(record, out, "fasta")
+
+############################################################
+# TRANSDECODER
+############################################################
+
+print("\n=== RUNNING TRANSDECODER ===")
+
+run_cmd(
+    ["TransDecoder.LongOrfs", "-t", str(merged_transcripts)],
+    cwd=str(results_dir)
+)
+
+run_cmd(
+    ["TransDecoder.Predict", "-t", str(merged_transcripts), "--cpu", str(threads)],
+    cwd=str(results_dir)
+)
+
+predicted_cds = merged_transcripts.with_suffix(
+    merged_transcripts.suffix + ".transdecoder.cds"
+)
+
+if not predicted_cds.exists():
+    raise RuntimeError(f"TransDecoder CDS file not found: {predicted_cds}")
+
+print(f"[INFO] Predicted CDS: {predicted_cds}")
+
+############################################################
+# BUILD BLAST DB
+############################################################
+
+cds_db = make_blast_db(predicted_cds, "nucl", blast_db_dir)
+
+transcript_index = SeqIO.to_dict(
+    SeqIO.parse(predicted_cds, "fasta")
+)
+
+############################################################
+# TBLASTN RECOVERY
+############################################################
+
+print("\n=== TBLASTN RECOVERY ===")
+
+recovered_cds = []
+
+for protein in orthogroup_proteins:
+
+    temp_query = results_dir / "temp_query.fasta"
+    SeqIO.write(protein, temp_query, "fasta")
+
+    blast_out = results_dir / "tblastn.tsv"
+
+    run_cmd([
+        "tblastn",
+        "-query", str(temp_query),
+        "-db", cds_db,
+        "-out", str(blast_out),
+        "-outfmt", "6 qseqid sseqid pident length qlen",
+        "-num_threads", str(threads)
+    ])
+
+    with open(blast_out) as f:
+        for line in f:
+            q, s, pident, length, qlen = line.strip().split()
+
+            if float(pident) >= identity_threshold and int(length) == int(qlen):
+                cds_seq = transcript_index[s].seq
+
+                # Remove terminal stop codon if present
+                if cds_seq[-3:].upper() in ["TAA", "TAG", "TGA"]:
+                    cds_seq = cds_seq[:-3]
+
+                recovered_cds.append(
+                    SeqRecord(
+                        cds_seq,
+                        id=protein.id,
+                        description=""
+                    )
+                )
+
+                break
+
+SeqIO.write(recovered_cds, cds_output, "fasta")
+print(f"[INFO] CDS orthogroup written: {cds_output}")
+
+############################################################
+# CLEANUP EVERYTHING EXCEPT FINAL OUTPUTS
+############################################################
+
+print("\n=== CLEANING INTERMEDIATES ===")
+
+keep = {protein_output.resolve(), cds_output.resolve()}
+
+for item in results_dir.iterdir():
+    if item.resolve() in keep:
+        continue
+    if item.is_dir():
+        for sub in item.rglob("*"):
+            try:
+                sub.unlink()
+            except:
+                pass
+        try:
+            item.rmdir()
+        except:
+            pass
+    else:
+        try:
+            item.unlink()
+        except:
+            pass
+
+print("\n✅ Orthogroup module complete.\n")

babappa-0.1.0/babappa/workflow/scripts/parse_absrel.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+
+import json
+from pathlib import Path
+from Bio import Phylo
+
+############################################################
+# Snakemake inputs
+############################################################
+
+absrel_json = Path(snakemake.input.json)
+tree_file = Path(snakemake.input.tree)
+output_file = Path(snakemake.output.branches)
+
+############################################################
+# Load absrel results
+############################################################
+
+with open(absrel_json) as f:
+    data = json.load(f)
+
+selected_branches = []
+
+# HyPhy structure
+branch_data = data.get("branch attributes", {}).get("0", {})
+
+for branch, info in branch_data.items():
+
+    # Try multiple possible keys
+    pval = (
+        info.get("Corrected P-value")
+        or info.get("p-value")
+        or info.get("p-value (corrected)")
+    )
+
+    if pval is None:
+        continue
+
+    try:
+        if float(pval) <= 0.05:
+            selected_branches.append(branch)
+    except:
+        continue
+
+############################################################
+# If none selected → fallback to all terminal branches
+############################################################
+
+if not selected_branches:
+
+    print("[INFO] No significant branches from absrel.")
+    print("[INFO] Falling back to all terminal branches.")
+
+    tree = Phylo.read(tree_file, "newick")
+
+    for clade in tree.get_terminals():
+        if clade.name:
+            selected_branches.append(clade.name)
+
+############################################################
+# Write output
+############################################################
+
+with open(output_file, "w") as out:
+    for branch in selected_branches:
+        out.write(branch + "\n")
+
+print(f"[INFO] Foreground branches: {len(selected_branches)}")

babappa-0.1.0/babappa.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: babappa
+Version: 0.1.0
+Summary: Evolutionary selection pipeline integrating RBH, codon alignment, HyPhy, PAML, and ancestral reconstruction.
+Author-email: Krishnendu Sinha <dr.krishnendusinha@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: biopython
+Requires-Dist: snakemake

babappa-0.1.0/babappa.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+babappa/__init__.py
+babappa/cli.py
+babappa.egg-info/PKG-INFO
+babappa.egg-info/SOURCES.txt
+babappa.egg-info/dependency_links.txt
+babappa.egg-info/entry_points.txt
+babappa.egg-info/requires.txt
+babappa.egg-info/top_level.txt
+babappa/workflow/scripts/ancestral_reconstruction.py
+babappa/workflow/scripts/codon_align.py
+babappa/workflow/scripts/dynamic_codeml.py
+babappa/workflow/scripts/orthogroup.py
+babappa/workflow/scripts/parse_absrel.py

babappa-0.1.0/babappa.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

babappa-0.1.0/babappa.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+babappa = babappa.cli:main

babappa-0.1.0/babappa.egg-info/requires.txt

@@ -0,0 +1,2 @@
+biopython
+snakemake

babappa-0.1.0/babappa.egg-info/top_level.txt

@@ -0,0 +1 @@
+babappa

babappa-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "babappa"
+version = "0.1.0"
+description = "Evolutionary selection pipeline integrating RBH, codon alignment, HyPhy, PAML, and ancestral reconstruction."
+authors = [
+    {name = "Krishnendu Sinha", email = "dr.krishnendusinha@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+dependencies = [
+    "biopython",
+    "snakemake"
+]
+
+[project.scripts]
+babappa = "babappa.cli:main"

babappa-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+