mgnify-pipelines-toolkit 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

mgnify_pipelines_toolkit/analysis/assembly/gff_annotation_utils.py

@@ -17,8 +17,19 @@
 
 import re
 import sys
+import fileinput
 
-from mgnify_pipelines_toolkit.constants.thresholds import EVALUE_CUTOFF_IPS, EVALUE_CUTOFF_EGGNOG
+from mgnify_pipelines_toolkit.constants.thresholds import (
+    EVALUE_CUTOFF_IPS,
+    EVALUE_CUTOFF_EGGNOG,
+)
+
+DBCAN_CLASSES_DICT = {
+    "TC": "dbcan_transporter_classification",
+    "TF": "dbcan_transcription_factor",
+    "STP": "dbcan_signal_transduction_prot",
+    "CAZyme": "dbcan_prot_family",
+}
 
 
 def get_iprs(ipr_annot):
@@ -26,7 +37,8 @@ def get_iprs(ipr_annot):
     antifams = list()
     if not ipr_annot:
         return iprs, antifams
-    with open(ipr_annot) as f:
+    with fileinput.hook_compressed(ipr_annot, "r", encoding="utf-8") as f:
+
         for line in f:
             cols = line.strip().split("\t")
             protein = cols[0]
@@ -55,7 +67,8 @@ def get_eggnog(eggnog_annot):
     eggnogs = {}
     if not eggnog_annot:
         return eggnogs
-    with open(eggnog_annot, "r") as f:
+    with fileinput.hook_compressed(eggnog_annot, "r", encoding="utf-8") as f:
+
         for line in f:
             line = line.rstrip()
             cols = line.split("\t")
@@ -104,7 +117,8 @@ def get_bgcs(bgc_file, prokka_gff, tool):
         return bgc_annotations
     # save positions of each BGC cluster to dictionary cluster_positions
     # and save the annotations to dictionary bgc_result
-    with open(bgc_file, "r") as bgc_in:
+    with fileinput.hook_compressed(bgc_file, "r", encoding="utf-8") as bgc_in:
+
         for line in bgc_in:
             if not line.startswith("#"):
                 (
@@ -138,7 +152,7 @@ def get_bgcs(bgc_file, prokka_gff, tool):
                     type_value = ""
                     as_product = ""
                     for a in annotations.split(
-                            ";"
+                        ";"
                     ):  # go through all parts of the annotation field
                         if a.startswith("as_type="):
                             type_value = a.split("=")[1]
@@ -170,9 +184,12 @@ def get_bgcs(bgc_file, prokka_gff, tool):
                         {"bgc_function": type_value},
                     )
                     if as_product:
-                        tool_result[contig]["_".join([start_pos, end_pos])]["bgc_product"] = as_product
+                        tool_result[contig]["_".join([start_pos, end_pos])][
+                            "bgc_product"
+                        ] = as_product
     # identify CDSs that fall into each of the clusters annotated by the BGC tool
-    with open(prokka_gff, "r") as gff_in:
+    with fileinput.hook_compressed(prokka_gff, "r", encoding="utf-8") as gff_in:
+
         for line in gff_in:
             if not line.startswith("#"):
                 matching_interval = ""
@@ -228,8 +245,9 @@ def get_bgcs(bgc_file, prokka_gff, tool):
                             },
                         )
                         if "bgc_product" in tool_result[contig][matching_interval]:
-                            bgc_annotations[cds_id]["antismash_product"] = tool_result[contig][matching_interval][
-                                "bgc_product"]
+                            bgc_annotations[cds_id]["antismash_product"] = tool_result[
+                                contig
+                            ][matching_interval]["bgc_product"]
             elif line.startswith("##FASTA"):
                 break
     return bgc_annotations
@@ -239,7 +257,7 @@ def get_amr(amr_file):
     amr_annotations = {}
     if not amr_file:
         return amr_annotations
-    with open(amr_file, "r") as f:
+    with fileinput.hook_compressed(amr_file, "r", encoding="utf-8") as f:
         for line in f:
             if line.startswith("Protein identifier"):
                 continue
@@ -286,7 +304,7 @@ def get_dbcan(dbcan_file):
     substrates = dict()
     if not dbcan_file:
         return dbcan_annotations
-    with open(dbcan_file, "r") as f:
+    with fileinput.hook_compressed(dbcan_file, "r", encoding="utf-8") as f:
         for line in f:
             if "predicted PUL" in line:
                 annot_fields = line.strip().split("\t")[8].split(";")
@@ -314,13 +332,45 @@ def get_dbcan(dbcan_file):
                         elif a.startswith("Parent"):
                             parent = a.split("=")[1]
                     dbcan_annotations[acc] = (
-                        "dbcan_prot_type={};dbcan_prot_family={};substrate_dbcan-pul={};substrate_dbcan-sub={}".format(
+                        "dbcan_prot_type={};{}={};substrate_dbcan-pul={};substrate_dbcan-sub={}".format(
                             prot_type,
+                            DBCAN_CLASSES_DICT[prot_type],
                             prot_fam,
                             substrates[parent]["substrate_pul"],
                             substrates[parent]["substrate_ecami"],
                         )
                     )
+
+    return dbcan_annotations
+
+
+def get_dbcan_individual_cazys(dbcan_cazys_file):
+    dbcan_annotations = dict()
+    if not dbcan_cazys_file:
+        return dbcan_annotations
+    with fileinput.hook_compressed(dbcan_cazys_file, "r", encoding="utf-8") as f:
+        for line in f:
+            if line.startswith("#"):
+                continue
+            attributes = line.strip().split("\t")[8]
+            attributes_dict = dict(
+                re.split(r"(?<!\\)=", item)
+                for item in re.split(r"(?<!\\);", attributes.rstrip(";"))
+            )
+            if "num_tools" in attributes_dict and int(attributes_dict["num_tools"]) < 2:
+                continue  # don't keep annotations supported by only one tool within dbcan
+            cds_pattern = r"\.CDS\d+$"
+            protein = re.sub(
+                cds_pattern, "", attributes_dict["ID"]
+            )  # remove the CDS number
+            annotation_text = "dbcan_prot_type=CAZyme;"
+            for field in ["protein_family", "substrate_dbcan-sub", "eC_number"]:
+                if field in attributes_dict:
+                    annotation_text += (
+                        f"{'dbcan_prot_family' if field == 'protein_family' else field}"
+                        f"={attributes_dict[field]};"
+                    )
+            dbcan_annotations[protein] = annotation_text.strip(";")
     return dbcan_annotations
 
 
@@ -329,7 +379,8 @@ def get_defense_finder(df_file):
     type_info = dict()
     if not df_file:
         return defense_finder_annotations
-    with open(df_file, "r") as f:
+    with fileinput.hook_compressed(df_file, "r", encoding="utf-8") as f:
+
         for line in f:
             if "Anti-phage system" in line:
                 annot_fields = line.strip().split("\t")[8].split(";")
@@ -366,6 +417,7 @@ def load_annotations(
     antismash_file,
     gecco_file,
     dbcan_file,
+    dbcan_cazys_file,
     defense_finder_file,
     pseudofinder_file,
 ):
@@ -376,6 +428,7 @@ def load_annotations(
     antismash_bgcs = get_bgcs(antismash_file, in_gff, tool="antismash")
     amr_annotations = get_amr(amr_file)
     dbcan_annotations = get_dbcan(dbcan_file)
+    dbcan_cazys_annotations = get_dbcan_individual_cazys(dbcan_cazys_file)
     defense_finder_annotations = get_defense_finder(defense_finder_file)
     pseudogenes = get_pseudogenes(pseudofinder_file)
     pseudogene_report_dict = dict()
@@ -384,7 +437,7 @@ def load_annotations(
     header = []
     fasta = []
     fasta_flag = False
-    with open(in_gff) as f:
+    with fileinput.hook_compressed(in_gff, "r", encoding="utf-8") as f:
         for line in f:
             line = line.strip()
             if line[0] != "#" and not fasta_flag:
@@ -496,6 +549,11 @@ def load_annotations(
                         added_annot[protein]["dbCAN"] = dbcan_annotations[protein]
                     except KeyError:
                         pass
+                    try:
+                        dbcan_cazys_annotations[protein]
+                        added_annot[protein]["dbCAN"] = dbcan_cazys_annotations[protein]
+                    except KeyError:
+                        pass
                     try:
                         defense_finder_annotations[protein]
                         added_annot[protein]["defense_finder"] = (
@@ -530,7 +588,7 @@ def load_annotations(
 def get_ncrnas(ncrnas_file):
     ncrnas = {}
     counts = 0
-    with open(ncrnas_file, "r") as f:
+    with fileinput.hook_compressed(ncrnas_file, "r", encoding="utf-8") as f:
         for line in f:
             if not line.startswith("#"):
                 cols = line.strip().split()
@@ -543,7 +601,9 @@ def get_ncrnas(ncrnas_file):
                     # Skip tRNAs, we add them from tRNAscan-SE
                     continue
                 strand = cols[11]
-                start, end = (int(cols[9]), int(cols[10])) if strand == "+" else (int(cols[10]), int(cols[9]))
+                start, end = int(cols[10]), int(cols[9])
+                if strand == "+":
+                    start, end = end, start
                 rna_feature_name, ncrna_class = prepare_rna_gff_fields(cols)
                 annot = [
                     "ID=" + locus,
@@ -718,7 +778,10 @@ def prepare_rna_gff_fields(cols):
     }
 
     if rna_feature_name == "ncRNA":
-        ncrna_class = next((rna_type for rna_type, rfams in rna_types.items() if cols[2] in rfams), None)
+        ncrna_class = next(
+            (rna_type for rna_type, rfams in rna_types.items() if cols[2] in rfams),
+            None,
+        )
         if not ncrna_class:
             if "microRNA" in cols[-1]:
                 ncrna_class = "pre_miRNA"
@@ -729,7 +792,7 @@ def prepare_rna_gff_fields(cols):
 
 def get_trnas(trnas_file):
     trnas = {}
-    with open(trnas_file, "r") as f:
+    with fileinput.hook_compressed(trnas_file, "r", encoding="utf-8") as f:
         for line in f:
             if not line.startswith("#"):
                 cols = line.split("\t")
@@ -738,13 +801,13 @@ def get_trnas(trnas_file):
                     line = line.replace("tRNAscan-SE", "tRNAscan-SE:2.0.9")
                     trnas.setdefault(contig, dict()).setdefault(
                         int(start), list()
-                    ).append(line.strip())
+                    ).append(line.strip().strip(";"))
     return trnas
 
 
 def load_crispr(crispr_file):
     crispr_annotations = dict()
-    with open(crispr_file, "r") as f:
+    with fileinput.hook_compressed(crispr_file, "r", encoding="utf-8") as f:
         record = list()
         left_coord = ""
         loc_contig = ""
@@ -791,7 +854,7 @@ def get_pseudogenes(pseudofinder_file):
     pseudogenes = dict()
     if not pseudofinder_file:
         return pseudogenes
-    with open(pseudofinder_file) as file_in:
+    with fileinput.hook_compressed(pseudofinder_file, "r", encoding="utf-8") as file_in:
         for line in file_in:
             if not line.startswith("#"):
                 col9 = line.strip().split("\t")[8]

mgnify_pipelines_toolkit/analysis/assembly/gff_file_utils.py

@@ -28,6 +28,17 @@ def write_results_to_file(
         contig_list = check_for_additional_keys(
             ncrnas, trnas, crispr_annotations, contig_list
         )
+        # sort contigs by digit at the end of contig/genome accession
+        if contig_list[0].startswith(
+            "MGYG"
+        ):  # e.g. 'MGYG000500002_1', 'MGYG000500002_2', 'MGYG000500002_3'
+            contig_list = sorted(list(contig_list), key=lambda x: int(x.split("_")[-1]))
+        elif contig_list[0].startswith(
+            "ERZ"
+        ):  # e.g. 'ERZ1049444', 'ERZ1049445', 'ERZ1049446'
+            contig_list = sorted(
+                list(contig_list), key=lambda x: int(x.split("ERZ")[-1])
+            )
         for contig in contig_list:
             sorted_pos_list = sort_positions(
                 contig, main_gff_extended, ncrnas, trnas, crispr_annotations

mgnify_pipelines_toolkit/analysis/assembly/gff_toolkit.py

@@ -17,27 +17,39 @@
 
 import argparse
 
-from gff_annotation_utils import get_ncrnas, get_trnas, load_annotations, load_crispr
-from gff_file_utils import write_results_to_file, print_pseudogene_report
+from mgnify_pipelines_toolkit.analysis.assembly.gff_annotation_utils import (
+    get_ncrnas,
+    get_trnas,
+    load_annotations,
+    load_crispr,
+)
+from mgnify_pipelines_toolkit.analysis.assembly.gff_file_utils import (
+    write_results_to_file,
+    print_pseudogene_report,
+)
 
 
-def main(
-    gff,
-    ipr_file,
-    eggnog_file,
-    sanntis_file,
-    crispr_file,
-    amr_file,
-    antismash_file,
-    gecco_file,
-    dbcan_file,
-    defense_finder_file,
-    pseudofinder_file,
-    rfam_file,
-    trnascan_file,
-    outfile,
-    pseudogene_report_file,
-):
+def main():
+
+    (
+        gff,
+        ipr_file,
+        eggnog_file,
+        sanntis_file,
+        crispr_file,
+        amr_file,
+        antismash_file,
+        gecco_file,
+        dbcan_file,
+        dbcan_cazys_file,
+        defense_finder_file,
+        pseudofinder_file,
+        rfam_file,
+        trnascan_file,
+        outfile,
+        pseudogene_report_file,
+    ) = parse_args()
+
     # load annotations and add them to existing CDS
     # here header contains leading GFF lines starting with "#",
     # main_gff_extended is a dictionary that contains GFF lines with added in additional annotations
@@ -53,6 +65,7 @@ def main(
         antismash_file,
         gecco_file,
         dbcan_file,
+        dbcan_cazys_file,
         defense_finder_file,
         pseudofinder_file,
     )
@@ -66,7 +79,9 @@ def main(
     if crispr_file:
         crispr_annotations = load_crispr(crispr_file)
 
-    write_results_to_file(outfile, header, main_gff_extended, fasta, ncrnas, trnas, crispr_annotations)
+    write_results_to_file(
+        outfile, header, main_gff_extended, fasta, ncrnas, trnas, crispr_annotations
+    )
     if pseudogene_report_file:
         print_pseudogene_report(pseudogene_report_dict, pseudogene_report_file)
 
@@ -74,7 +89,7 @@ def main(
 def parse_args():
     parser = argparse.ArgumentParser(
         description="The script extends a user-provided base GFF annotation file by incorporating "
-                    "information extracted from the user-provided outputs of supplementary annotation tools.",
+        "information extracted from the user-provided outputs of supplementary annotation tools.",
     )
     parser.add_argument(
         "-g",
@@ -124,7 +139,12 @@ def parse_args():
     )
     parser.add_argument(
         "--dbcan",
-        help="The GFF file produced by dbCAN post-processing script",
+        help="The GFF file produced by dbCAN post-processing script that uses cluster annotations",
+        required=False,
+    )
+    parser.add_argument(
+        "--dbcan-cazys",
+        help="The GFF file produced by dbCAN-CAZYs post-processing script",
         required=False,
     )
     parser.add_argument(
@@ -146,12 +166,8 @@ def parse_args():
         "--pseudogene-report", help="Pseudogene report filename", required=False
     )
 
-    return parser.parse_args()
-
-
-if __name__ == '__main__':
-    args = parse_args()
-    main(
+    args = parser.parse_args()
+    return (
         args.gff_input,
         args.ips,
         args.eggnog,
@@ -161,10 +177,15 @@ if __name__ == '__main__':
         args.antismash,
         args.gecco,
         args.dbcan,
+        args.dbcan_cazys,
         args.defense_finder,
         args.pseudofinder,
         args.rfam,
         args.trnascan,
         args.outfile,
         args.pseudogene_report,
-         )
+    )
+
+
+if __name__ == "__main__":
+    main()

mgnify_pipelines_toolkit/analysis/assembly/process_dbcan_result_cazys.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright 2023-2025 EMBL - European Bioinformatics Institute
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import argparse
+import fileinput
+import logging
+from pathlib import Path
+import re
+
+logging.basicConfig(level=logging.INFO)
+
+
+def main():
+
+    args = parse_args()
+    hmm_file, overview_file, genome_gff, outfile, dbcan_ver = (
+        args.hmm_file,
+        args.overview_file,
+        args.genome_gff,
+        args.outfile,
+        args.dbcan_ver,
+    )
+
+    hmm_path = Path(hmm_file)
+    overview_path = Path(overview_file)
+
+    if not hmm_path.is_file():
+        raise FileNotFoundError(f"Input hmm path does not exist: {hmm_file}")
+
+    if not overview_path.is_file():
+        raise FileNotFoundError(f"Input overview path does not exist: {overview_file}")
+
+    substrates = load_substrates(hmm_path)
+    genome_gff_lines = load_gff(genome_gff)
+
+    print_gff(overview_file, outfile, dbcan_ver, substrates, genome_gff_lines)
+
+
+def load_gff(gff):
+    genome_gff_lines = dict()
+    with fileinput.hook_compressed(gff, "rt") as gff:
+        for line in gff:
+            if line.startswith("##FASTA"):
+                return genome_gff_lines
+
+            fields = line.strip().split("\t")
+            if len(fields) != 9 or fields[2] != "CDS":
+                continue
+
+            if "Parent=" in line:
+                # Get transcript name from the 9th column for mettannotator
+                match = re.search(r"Parent=([^;]+)", fields[8])
+            elif "ID=" in line:
+                # Get transcript name from the 9th column for ASA
+                match = re.search(r"ID=([^;]+)", fields[8])
+            else:
+                logging.error(
+                    "Not sure what gff annotation delimiter is in use. Exiting"
+                )
+                exit(1)
+
+            transcript_name = match.group(1)
+            genome_gff_lines.setdefault(transcript_name, []).append(line)
+    return genome_gff_lines
+
+
+def print_gff(overview_file, outfile, dbcan_version, substrates, genome_gff_lines):
+    with open(outfile, "w") as file_out:
+        file_out.write("##gff-version 3\n")
+        with fileinput.hook_compressed(overview_file, "rt") as file_in:
+            for line in file_in:
+                if line.startswith("MGYG") or line.startswith("ERZ"):
+                    (
+                        transcript,
+                        ec_number_raw,
+                        dbcan_hmmer,
+                        dbcan_sub_ecami,
+                        diamond,
+                        num_of_tools,
+                    ) = line.strip().split("\t")
+                    # EC is reported as 2.4.99.-:5 with :5 meaning 5 proteins in the subfamily have EC 2.4.99.-
+
+                    ec_number = ""
+                    ec_list = ec_number_raw.split("|")
+                    for ec in ec_list:
+                        if ec != "-":
+                            ec_number += ec.split(":")[0] + "|"
+
+                    ec_number = ec_number.strip("|")
+
+                    # Dbcan recommends to use subfamily preference as dbcan_hmmer > dbcan_sub_ecami > diamond
+                    # diamond is messier, so we don't report it here
+                    if dbcan_hmmer != "-":
+                        # the field dbcan_hmmer reports match positions in parentheses, clear them out first:
+                        subfamily = dbcan_hmmer.split("(")[0]
+                    elif dbcan_sub_ecami != "-":
+                        subfamily = dbcan_sub_ecami
+                    else:
+                        continue
+                    cleaned_substrates = ",".join(
+                        sorted(
+                            {
+                                subsrate.strip()
+                                for subsrate in substrates.get(transcript, "N/A").split(
+                                    ","
+                                )
+                            }
+                        )
+                    )
+                    # Assemble information to add to the 9th column
+                    col9_parts = [
+                        f"protein_family={subfamily}",
+                        f"substrate_dbcan-sub={cleaned_substrates}",
+                    ]
+
+                    if ec_number:
+                        col9_parts.append(f"eC_number={ec_number}")
+
+                    col9_parts.append(f"num_tools={num_of_tools}")
+                    col9_text = ";".join(col9_parts)
+
+                    for gff_line in genome_gff_lines[transcript]:
+                        fields = gff_line.strip().split("\t")
+                        # Replace the tool
+                        fields[1] = f"dbCAN:{dbcan_version}"
+                        # Replace the feature
+                        fields[2] = "CAZyme"
+                        # Replace the confidence value
+                        fields[5] = "."
+                        # Keep only the ID in the 9th column
+                        attributes = fields[8].split(";")[0]
+                        # Add dbcan information to the 9th column
+                        attributes = f"{attributes};{col9_text};"
+                        fields[8] = attributes
+                        file_out.write("\t".join(fields) + "\n")
+
+
+def load_substrates(hmm_path):
+    substrates = dict()
+    with fileinput.hook_compressed(hmm_path, "rt") as file_in:
+        header = next(file_in)
+        header_fields = header.strip().split("\t")
+        substrate_idx = header_fields.index("Substrate")
+        gene_idx = header_fields.index("Gene ID")
+        evalue_idx = header_fields.index("E Value")
+        for line in file_in:
+            fields = line.strip().split("\t")
+            if float(fields[evalue_idx]) < 1e-15:  # evalue is the default from dbcan
+                substrate = fields[substrate_idx]
+                if not substrate == "-":
+                    gene_id = fields[gene_idx]
+                    substrates.setdefault(gene_id, []).append(substrate)
+    # resolve cases with multiple substrates
+    for gene_id, substrate_list in substrates.items():
+        substrate_list = list(set(substrate_list))
+        if len(substrate_list) == 1:
+            substrates[gene_id] = substrate_list[0]
+        else:
+            substrates[gene_id] = ",".join(substrate_list)
+    return substrates
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description=(
+            "The script takes dbCAN output for a eukaryotic genome and parses it to create a standalone GFF."
+        )
+    )
+    parser.add_argument(
+        "-hmm",
+        dest="hmm_file",
+        required=True,
+        help="Path to the hmm file.",
+    )
+    parser.add_argument(
+        "-ov",
+        dest="overview_file",
+        required=True,
+        help="Path to the overview file.",
+    )
+    parser.add_argument(
+        "-g",
+        dest="genome_gff",
+        required=True,
+        help="Path to the genome GFF.",
+    )
+    parser.add_argument(
+        "-o",
+        dest="outfile",
+        required=True,
+        help="Path to the output file.",
+    )
+    parser.add_argument(
+        "-v",
+        dest="dbcan_ver",
+        required=True,
+        help="dbCAN version used.",
+    )
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

mgnify_pipelines_toolkit/analysis/assembly/process_dbcan_result_clusters.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+
+# Copyright 2023-2024 EMBL - European Bioinformatics Institute
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import argparse
+import fileinput
+import logging
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO)
+
+
+def main():
+
+    args = parse_args()
+    standard_file, substrate_file, outfile, dbcan_ver = (
+        args.standard_file,
+        args.substrate_file,
+        args.outfile,
+        args.dbcan_ver,
+    )
+    standard_path = Path(standard_file)
+    substrate_path = Path(substrate_file)
+
+    if not standard_path.exists():
+        raise FileNotFoundError(f"Input standards path does not exist: {standard_file}")
+
+    if not substrate_path.exists():
+        raise FileNotFoundError(
+            f"Input substrate path does not exist: {substrate_file}"
+        )
+
+    substrates = load_substrates(substrate_path)
+    cgc_locations = load_cgcs(standard_path)
+    print_gff(standard_path, outfile, dbcan_ver, substrates, cgc_locations)
+
+
+def load_cgcs(standard_path):
+    cgc_locations = dict()
+    with fileinput.hook_compressed(standard_path, "rt") as file_in:
+        for line in file_in:
+            if not line.startswith("CGC#"):
+                cgc, _, contig, _, start, end, _, _ = line.strip().split("\t")
+                cgc_id = f"{contig}_{cgc}"
+                if cgc_id in cgc_locations:
+                    if cgc_locations[cgc_id]["start"] > int(start):
+                        cgc_locations[cgc_id]["start"] = int(start)
+                    if cgc_locations[cgc_id]["end"] < int(end):
+                        cgc_locations[cgc_id]["end"] = int(end)
+                else:
+                    cgc_locations[cgc_id] = {
+                        "start": int(start),
+                        "end": int(end),
+                        "contig": contig,
+                    }
+    return cgc_locations
+
+
+def print_gff(standard_path, outfile, dbcan_version, substrates, cgc_locations):
+    with open(outfile, "w") as file_out:
+        file_out.write("##gff-version 3\n")
+        cgcs_printed = list()
+        with fileinput.hook_compressed(standard_path, "rt") as file_in:
+            for line in file_in:
+                if not line.startswith("CGC#"):
+                    cgc, gene_type, contig, prot_id, start, end, strand, protein_fam = (
+                        line.strip().split("\t")
+                    )
+                    cgc_id = f"{contig}_{cgc}"
+                    protein_fam = protein_fam.replace(" ", "")
+                    if cgc_id not in cgcs_printed:
+                        substrate = (
+                            substrates[cgc_id]
+                            if cgc_id in substrates
+                            else "substrate_dbcan-pul=N/A;substrate_dbcan-sub=N/A"
+                        )
+                        file_out.write(
+                            "{}\tdbCAN:{}\tpredicted PUL\t{}\t{}\t.\t.\t.\tID={};{}\n".format(
+                                contig,
+                                dbcan_version,
+                                cgc_locations[cgc_id]["start"],
+                                cgc_locations[cgc_id]["end"],
+                                cgc_id,
+                                substrate,
+                            )
+                        )
+                        cgcs_printed.append(cgc_id)
+                    file_out.write(
+                        (
+                            f"{contig}\tdbCAN:{dbcan_version}\t{gene_type}\t{start}"
+                            + f"\t{end}\t.\t{strand}\t.\tID={prot_id};Parent={cgc_id};protein_family={protein_fam}\n"
+                        )
+                    )
+
+
+def load_substrates(substrate_path):
+    substrates = dict()
+    with fileinput.hook_compressed(substrate_path, "rt") as file_in:
+        for line in file_in:
+            if not line.startswith("#"):
+                parts = line.strip().split("\t")
+                cgc_parts = parts[0].rsplit("|", 1)
+                cgc = "_".join(cgc_parts)
+                try:
+                    substrate_pul = parts[2]
+                except IndexError:
+                    substrate_pul = "N/A"
+                try:
+                    substrate_ecami = parts[5]
+                except IndexError:
+                    substrate_ecami = "N/A"
+                if not substrate_pul:
+                    substrate_pul = "N/A"
+                if not substrate_ecami:
+                    substrate_ecami = "N/A"
+                substrates[cgc] = (
+                    f"substrate_dbcan-pul={substrate_pul};substrate_dbcan-sub={substrate_ecami}"
+                )
+
+    return substrates
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description=(
+            "The script takes dbCAN output and parses it to create a standalone GFF."
+        )
+    )
+    parser.add_argument(
+        "-st",
+        dest="standard_file",
+        required=True,
+        help="Path to the standard file (*cgc_standard.out)",
+    )
+    parser.add_argument(
+        "-sb",
+        dest="substrate_file",
+        required=True,
+        help="Path to the substrate file (*substrate.out)",
+    )
+    parser.add_argument(
+        "-o",
+        dest="outfile",
+        required=True,
+        help="Path to the output file.",
+    )
+    parser.add_argument(
+        "-v",
+        dest="dbcan_ver",
+        required=True,
+        help="dbCAN version used.",
+    )
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

mgnify_pipelines_toolkit/analysis/assembly/summarise_antismash_bgcs.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2025 EMBL - European Bioinformatics Institute
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import fileinput
+import logging
+import pandas as pd
+
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s: %(message)s"
+)
+
+ANTISMASH_VERSION = "7.1.x"
+
+f"""
+Script parses antismash GFF output and adds descriptions from pre-parsed glossary https://docs.antismash.secondarymetabolites.org/glossary/.
+Glossary was taken from version {ANTISMASH_VERSION} and commit dbeeb0e https://github.com/antismash/documentation/blob/master/docs/glossary.md
+"""
+
+DESCRIPTIONS = {
+    "2dos": "2-deoxy-streptamine aminoglycoside",
+    "acyl_amino_acids": "N-acyl amino acid",
+    "amglyccycl": "Aminoglycoside/aminocyclitol",
+    "aminocoumarin": "Aminocoumarin",
+    "aminopolycarboxylic-acid": "Aminopolycarboxylic acid metallophores (doi:10.1039/C8MT00009C)",
+    "archaeal-ripp": "Archaeal RiPPs (doi:10.1021/jacs.2c00521 supplemental)",
+    "arylpolyene": "Aryl polyene",
+    "atropopeptide": "Atropopeptide RiPPs, e.g. scabrirubin and tryptorubin",
+    "azoxy-crosslink": "axoxy compounds formed by carboxilic cross-link",
+    "azoxy-dimer": "axoxy compounds formed by dimerisation",
+    "benzoxazole": "Benzoxazoles",
+    "betalactone": "Beta-lactone containing protease inhibitor",
+    "blactam": "β-lactam",
+    "bottromycin": "Bottromycin",
+    "butyrolactone": "Butyrolactone",
+    "cdps": "tRNA-dependent cyclodipeptide synthases",
+    "crocagin": "Crocagin-like",
+    "cyanobactin": "Cyanobactins like patellamide (AY986476)",
+    "cyclic-lactone-autoinducer": "agrD-like cyclic lactone autoinducer peptides (AF001782)",
+    "cytokinin": "Adenine-type cytokinins, e.g. fusatin and trans-zeatin",
+    "darobactin": "Darobactin-like compounds",
+    "deazapurine": "Deazapurine",
+    "ectoine": "Ectoine",
+    "epipeptide": "D-amino-acid containing RiPPs such as yydF (D78193)",
+    "fungal_cdps": "Fungal cyclodipeptide synthases",
+    "fungal-ripp": "Fungal RiPP with POP or UstH peptidase types and a modification",
+    "furan": "Furan",
+    "glycocin": "Glycocin",
+    "guanidinotides": "Pheganomycin-style protein ligase-containing cluster",
+    "hgle-ks": "Heterocyst glycolipid synthase-like PKS",
+    "hr-t2pks": "Highly reducing type II PKS like ishigamide and skyllamycin",
+    "hserlactone": "Homoserine lactone",
+    "hydrogen-cyanide": "Hydrogen cyanide (AF208523, doi:10.1128/jb.182.24.6940-6949.20)",
+    "hydroxy-tropolone": "7-hydroxytropolone-like cluster",
+    "indole": "Indole",
+    "isocyanide": "Isocyanides (doi:10.1093/nar/gkad573)",
+    "nrp with isocyanide": "Isocyanides (doi:0.1128/mBio.00785-18)",
+    "ladderane": "Ladderane",
+    "lanthipeptide class i": "Class I lanthipeptides like nisin",
+    "lanthipeptide class ii": "Class II lanthipeptides like mutacin II (U40620)",
+    "lanthipeptide class iii": "Class III lanthipeptides like labyrinthopeptin (FN178622)",
+    "lanthipeptide class iv": "Class IV lanthipeptides like venezuelin (HQ328852)",
+    "lanthipeptide class v": "Glycosylated lanthipeptide/linaridin hybrids like MT210103",
+    "lassopeptide": "Lasso peptide",
+    "leupeptin": "leupeptin-like compounds",
+    "linaridin": "Linear arid peptide such as cypemycin (HQ148718) and salinipeptin (MG788286)",
+    "lincosamides": "NRPS-adjacent biosynthesis of lincosamides",
+    "lipolanthine": "Lanthipeptide class containing N-terminal fatty acids such as MG673929",
+    "melanin": "Melanin",
+    "methanobactin": "Copper-chelating/transporting peptides (doi:10.1126/science.aap9437)",
+    "microviridin": "Microviridin",
+    "mycosporine": "Molecules containing mycosporine-like amino acid",
+    "naggn": "N-acetylglutaminylglutamine amide",
+    "napaa": "Non-alpha poly-amino acids like e-Polylysin",
+    "ni-siderophore": "NRPS-independent, IucA/IucC-like siderophores (*siderophore* prior to 7.0)",
+    "nitropropanoic-acid": "3-Nitropropanoic acid (neurotoxin)",
+    "nrps": "Non-ribosomal peptide synthetase",
+    "nrp-metallophore": "Non-ribosomal peptide metallophores",
+    "nucleoside": "Nucleoside",
+    "oligosaccharide": "Oligosaccharide",
+    "opine-like-metallophore": "Opine-like zincophores like staphylopine (doi:10.1128/mSystems.00554-20)",
+    "other": "Cluster containing a secondary metabolite-related protein that does not fit into any other category",
+    "pbde": "Polybrominated diphenyl ether",
+    "phenazine": "Phenazine",
+    "phosphoglycolipid": "Phosphoglycolipid",
+    "phosphonate": "Phosphonate",
+    "polyhalogenated-pyrrole": "Polyhalogenated pyrrole",
+    "polyyne": "Polyyne",
+    "ppys-ks": "PPY-like pyrone",
+    "prodigiosin": "Serratia-type non-traditional PKS prodigiosin biosynthesis pathway",
+    "proteusin": "Proteusin",
+    "pufa": "Polyunsaturated fatty acid",
+    "pyrrolidine": "Pyrrolidines like described in BGC0001510",
+    "ranthipeptide": "Cys-rich peptides (aka. SCIFF: six Cys in fourty-five) like in CP001581:3481278-3502939",
+    "ras-ripp": "Streptide-like thioether-bond RiPPs",
+    "rcdps": "Fungal Arginine-containing cyclic dipeptides",
+    "redox-cofactor": "Redox-cofactors such as PQQ (NC_021985:1458906-1494876)",
+    "resorcinol": "Resorcinol",
+    "sactipeptide": "Sactipeptide",
+    "spliceotide": "RiPPs containing plpX type spliceases (NZ_KB235920:17899-42115)",
+    "t1pks": "Type I PKS (Polyketide synthase)",
+    "t2pks": "Type II PKS",
+    "t3pks": "Type III PKS",
+    "terpene": "Terpene",
+    "thioamitides": "Thioamitide RiPPs as found in JOBF01000011",
+    "thioamide-nrp": "Thioamide-containing non-ribosomal peptide",
+    "transat-pks": "Trans-AT PKS",
+    "triceptide": "Triceptides",
+    "tropodithietic-acid": "Tropodithietic acid",
+    "fungal-ripp-like": "Fungal RiPP-likes",
+    "nrps-like": "NRPS-like fragment",
+    "phosphonate-like": "Phosphonate-like (prior to 7.0 this was the phosphonate rule)",
+    "pks-like": "Other types of PKS",
+    "ripp-like": "Other unspecified ribosomally synthesised and post-translationally modified peptide product (RiPP)",
+    "rre-containing": "RRE-element containing cluster",
+    "terpene-precursor": "Compound likely used as a terpene precursor",
+    "transat-pks-like": "Trans-AT PKS fragment, with trans-AT domain not found",
+    "fatty_acid": "Fatty acid (loose strictness, likely from primary metabolism)",
+    "halogenated": "Halogenase-containing cluster, potentially generating a halogenated product",
+    "lysine": "Fungal lysine primary metabolism",
+    "saccharide": "Saccharide (loose strictness, likely from primary metabolism)",
+    "lap": "Linear azol(in)e-containing peptides",
+    "mycosporine-like": "Molecules containing mycosporine-like amino acid",
+    "thiopeptide": "Thiopeptide",
+    "siderophore": "Siderophore",
+    "bacteriocin": "Bacteriocin or other unspecified ribosomally synthesised and  post-translationally modified peptide product (RiPP)",
+    "fused": "Pheganomycin-style protein ligase-containing cluster",
+    "head_to_tail": "Head-to-tail cyclised RiPP (subtilosin-like)",
+    "lanthidin": "Glycosylated lanthipeptide/linaridin hybrids like MT210103",
+    "lanthipeptide": "Lanthipeptides",
+    "tfua-related": "TfuA-related RiPPs",
+    "otherks": "Other types of PKS",
+    "microcin": "Microcin",
+    "cf_saccharide": "Possible saccharide",
+    "cf_fatty_acid": "Possible fatty acid",
+    "cf_putative": "Putative cluster of unknown type identified  with the ClusterFinder algorithm",
+}
+
+
+def parse_args():
+    description = (
+        "antiSMASH output summary generator. "
+        "Script takes regions from GFF and counts its appearance in annotation. "
+        "Output columns contain classID, descriptions and count. "
+        f"Descriptions were taken from pre-parsed glossary provided on antiSMASH website. "
+        f"Current script supports antiSMASH results for version {ANTISMASH_VERSION} and older."
+    )
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument("-i", "--antismash-gff", help="antiSMASH GFF", required=True)
+    parser.add_argument(
+        "-o", "--output", help="Antisamsh summary TSV output file.", required=True
+    )
+    parser.add_argument(
+        "-a",
+        "--antismash-version",
+        help="antiSMASH version that was used to generate GFF",
+        required=False,
+        default=ANTISMASH_VERSION,
+    )
+    args = parser.parse_args()
+    if args.antismash_version > ANTISMASH_VERSION:
+        logging.error(
+            "Provided version of antiSMASH is bigger than supported. "
+            "Please, make sure you have updated descriptions dictionary. Exit."
+        )
+        exit(1)
+    return args.antismash_gff, args.output
+
+
+def main():
+    input_gff, output_filename = parse_args()
+    dict_list = []
+    with fileinput.hook_compressed(input_gff, "r") as file_in:
+        # TODO: to be merged with the GFF toolkit
+        for line in file_in:
+            if line.startswith("#"):
+                continue
+            info = line.strip().split("\t")[8].split(";")
+            entry_dict = {}
+            for pair in info:
+                key, value = pair.split(
+                    "=", 1
+                )  # Ensure split only occurs at the first '=' occurrence
+                entry_dict[key] = value
+            dict_list.append(entry_dict)
+
+        # Convert to DataFrame
+        df = pd.DataFrame(dict_list)
+        df = df[df["product"].notna()]
+        df_grouped = (
+            df.groupby(["product"]).size().reset_index(name="Count")
+        ).sort_values(by="Count", ascending=False)
+
+        df_grouped = df_grouped.rename(
+            columns={
+                "product": "label",
+            }
+        )
+        df_grouped["Description"] = df_grouped["label"].apply(
+            lambda x: ",".join(
+                [
+                    DESCRIPTIONS.get(cls.strip().lower(), cls.strip())
+                    for cls in x.split(",")
+                ]
+            )
+        )
+        df_grouped = df_grouped[["label", "Description", "Count"]]
+        df_grouped = df_grouped.rename(columns={
+            "Description": "description",
+            "Count": "count"
+        })
+        df_grouped.to_csv(output_filename, sep="\t", index=False)
+
+
+if __name__ == "__main__":
+    main()

mgnify_pipelines_toolkit/analysis/assembly/summarise_sanntis_bgcs.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2025 EMBL - European Bioinformatics Institute
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import fileinput
+import logging
+import pandas as pd
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s: %(message)s"
+)
+
+SANNTIS_VERSION = "0.9.4.1"
+
+f"""
+Script parses SanntiS GFF output and adds descriptions of annotated MIBiGs classes.
+Descriptions were pre-parsed for version {SANNTIS_VERSION} and stored as a dictionary.
+"""
+
+DESCRIPTIONS = {
+    "Polyketide": "Built from iterative condensation of acetate units derived from acetyl-CoA",
+    "Terpene": "Composed of isoprene (C5) units derived from isopentenyl pyrophosphate",
+    "Alkaloid": "Nitrogen-containing compounds derived from amino acids (e.g., ornithine, lysine, tyrosine, tryptophan)",
+    "RiPP": "Ribosomally synthesised and Post-translationally modified Peptide",
+    "NRP": "Nonribosomal Peptide",
+    "Saccharide": "Carbohydrate-based natural products (e.g., aminoglycoside antibiotics)",
+    "Other": "Catch-all class for clusters encoding metabolites outside main classes (e.g., cyclitols, indolocarbazoles, and phosphonates)",
+}
+
+
+def parse_args():
+    description = (
+        "Sanntis output summary generator. "
+        "Script takes SanntiS GFF and counts pairs of (nearest_MiBIG, nearest_MiBIG_class)."
+        "It also adds pre-parsed descriptions of classes stored in that script as a dictionary. "
+        f"Descriptions were taken from SanntiS docs v{SANNTIS_VERSION}."
+    )
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument("-i", "--sanntis-gff", help="SanntiS GFF", required=True)
+    parser.add_argument(
+        "-o", "--output", help="SanntiS summary TSV output file.", required=True
+    )
+    args = parser.parse_args()
+    return args.sanntis_gff, args.output
+
+
+def main():
+    input_gff, output_filename = parse_args()
+    dict_list = []
+    with fileinput.hook_compressed(input_gff, "r") as file_in:
+        # TODO: to be merged with the GFF toolkit
+        for line in file_in:
+            if line.startswith("#"):
+                continue
+            info = line.strip().split("\t")[8].split(";")
+            entry_dict = {}
+            # TODO: merge this with the GFF toolkit GFF reader
+            for pair in info:
+                key, value = pair.split(
+                    "=", 1
+                )  # Ensure split only occurs at the first '=' occurrence
+                entry_dict[key] = value
+            dict_list.append(entry_dict)
+
+            # Convert to DataFrame
+        df = pd.DataFrame(dict_list)
+        df = df.rename(
+            columns={
+                "nearest_MiBIG": "nearest_MIBiG",
+                "nearest_MiBIG_class": "nearest_MIBiG_class",
+            }
+        )
+        df_grouped = (
+            df.groupby(["nearest_MIBiG", "nearest_MIBiG_class"])
+            .size()
+            .reset_index(name="Count")
+        )
+        df_grouped = df_grouped.sort_values(by="Count", ascending=False)
+
+        df_desc = pd.DataFrame(
+            list(DESCRIPTIONS.items()), columns=["MIBiG_class", "Description"]
+        )
+        df_desc = df_desc.set_index("MIBiG_class")
+        df_merged = df_grouped.merge(
+            df_desc, left_on="nearest_MIBiG_class", right_index=True, how="left"
+        )
+        df_merged["Description"] = df_merged.apply(
+            lambda row: row["nearest_MIBiG_class"].replace(
+                "NRP", df_desc.loc["NRP"]["Description"]
+            )
+            if pd.isna(row["Description"]) and "NRP" in row["nearest_MIBiG_class"]
+            else row["Description"],
+            axis=1,
+        )
+        df_merged = df_merged[
+            ["nearest_MIBiG", "nearest_MIBiG_class", "Description", "Count"]
+        ]
+        df_merged = df_merged.rename(columns={
+            "Description": "description",
+            "Count": "count"
+        })
+        df_merged.to_csv(output_filename, sep="\t", index=False)
+
+
+if __name__ == "__main__":
+    main()

mgnify_pipelines_toolkit/analysis/shared/convert_cmscan_to_cmsearch_tblout.py

@@ -62,9 +62,12 @@ class TableModifier:
         self.output_file = output_file
 
     def modify_table(self):
-        with fileinput.hook_compressed(self.input_file, "rt") as file_in, open(
-            self.output_file, "w"
-        ) as file_out:
+        with (
+            fileinput.hook_compressed(
+                self.input_file, "r", encoding="utf-8"
+            ) as file_in,
+            open(self.output_file, "w") as file_out,
+        ):
             header_written = False
             separator_line, header = "", ""
             for line in file_in:

mgnify_pipelines_toolkit/constants/thresholds.py

@@ -26,9 +26,9 @@ MAX_INTERNAL_PRIMER_PROPORTION = 0.2
 # used by library_strategy_checker in analysis.shared
 MIN_AMPLICON_STRATEGY_CHECK = 0.30
 
+
 # used by markergene_study_summary in analysis.shared
 MAJORITY_MARKER_PROPORTION = 0.45
-
 # used by gff_toolkit in analysis.assembly
 EVALUE_CUTOFF_IPS = 1e-10
 EVALUE_CUTOFF_EGGNOG = 1e-10

{mgnify_pipelines_toolkit-1.0.4.dist-info → mgnify_pipelines_toolkit-1.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mgnify_pipelines_toolkit
-Version: 1.0.4
+Version: 1.0.6
 Summary: Collection of scripts and tools for MGnify pipelines
 Author-email: MGnify team <metagenomics-help@ebi.ac.uk>
 License: Apache Software License 2.0

{mgnify_pipelines_toolkit-1.0.4.dist-info → mgnify_pipelines_toolkit-1.0.6.dist-info}/RECORD

@@ -16,15 +16,19 @@ mgnify_pipelines_toolkit/analysis/assembly/add_rhea_chebi_annotation.py,sha256=N
 mgnify_pipelines_toolkit/analysis/assembly/antismash_gff_builder.py,sha256=wXrw1B-z4hOu5oA27Vp1WYxGP2Mk6ZY4i_T5jDZgek0,6954
 mgnify_pipelines_toolkit/analysis/assembly/combined_gene_caller_merge.py,sha256=Pq-9RSt3RCxzDMQVW1VHlHF4NtpVwCWFbg2CMkvpZZc,19089
 mgnify_pipelines_toolkit/analysis/assembly/generate_gaf.py,sha256=2T4T7aXMGPac-LZUXJF3lOUzZZF50dAKkKTSaO-4idQ,3587
-mgnify_pipelines_toolkit/analysis/assembly/gff_annotation_utils.py,sha256=IlkeP4DuN7rXJIHa7o2sONHAXLhV9nGP-5Y1_0u8YQo,31393
-mgnify_pipelines_toolkit/analysis/assembly/gff_file_utils.py,sha256=8kv_6KWznOVRkeAtghLf4pxKPhAqdn36LOK4MsTz9hU,3282
-mgnify_pipelines_toolkit/analysis/assembly/gff_toolkit.py,sha256=uUIo97gmzO2zzN-pYF5paIzeHWBsmmjFp7zGAhf4PKY,5021
+mgnify_pipelines_toolkit/analysis/assembly/gff_annotation_utils.py,sha256=6gbCRlEX1eBqzFYjOt3og-961dZ--QsCJL-7l5nzg1k,33992
+mgnify_pipelines_toolkit/analysis/assembly/gff_file_utils.py,sha256=_4J31wAjK5B15p9lDzTG2wmZdyoZkOgmy7Kp_w8lTeE,3812
+mgnify_pipelines_toolkit/analysis/assembly/gff_toolkit.py,sha256=_iaTBvMKbQDi_02_QuSPqLJ_rC37ruxiPHv5lLQmI-w,5480
 mgnify_pipelines_toolkit/analysis/assembly/go_utils.py,sha256=eay9e3Xdc8XxnlC_4SHHjN89k-M9i_cFMc2lI_ZFxqY,5596
 mgnify_pipelines_toolkit/analysis/assembly/krona_txt_from_cat_classification.py,sha256=uex2T6GagtYFBIc39-Xm4SFHL06KAQ5v0_loOmY_eaw,4289
+mgnify_pipelines_toolkit/analysis/assembly/process_dbcan_result_cazys.py,sha256=5lbVSWRZoi61cKvuolzUJlhUBzpx8DgWMH0Vzw1HcHA,7748
+mgnify_pipelines_toolkit/analysis/assembly/process_dbcan_result_clusters.py,sha256=i4uYdqY6y2ee72vl0sLkHeJvigHGKJMzdyR3HEIK1Mk,5930
+mgnify_pipelines_toolkit/analysis/assembly/summarise_antismash_bgcs.py,sha256=eRAQ0vFbqnWreiBdtFuwLKve9WwYwv9dYQtD1pumaZs,10776
 mgnify_pipelines_toolkit/analysis/assembly/summarise_goslims.py,sha256=TPaKlYkoy37_XgYNOskWCCoXtPNku_k5ygSeK4fT1VQ,6689
+mgnify_pipelines_toolkit/analysis/assembly/summarise_sanntis_bgcs.py,sha256=65szj-H8Hxy_eXy3TyTs48EhPJbJ2w1skHlVbH2YeVM,4538
 mgnify_pipelines_toolkit/analysis/genomes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mgnify_pipelines_toolkit/analysis/shared/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mgnify_pipelines_toolkit/analysis/shared/convert_cmscan_to_cmsearch_tblout.py,sha256=0Ot1j4LPsEPyPbySSAh6n9s5Dilm_8_M9YQvTnQ-1PQ,4415
+mgnify_pipelines_toolkit/analysis/shared/convert_cmscan_to_cmsearch_tblout.py,sha256=kAGU5kQyj-Hlcdx32i-xOJSuHYYUDj-kqnyYHMohHGc,4477
 mgnify_pipelines_toolkit/analysis/shared/dwc_summary_generator.py,sha256=hggPqv9QawWAccm5tmru4VF9VnQAHF5LCXnqyLw_BWI,6727
 mgnify_pipelines_toolkit/analysis/shared/fastq_suffix_header_check.py,sha256=ye0Jka6_lNn4dQGb2QG3YT46y7QK0QvyaIitIaS8JVQ,4026
 mgnify_pipelines_toolkit/analysis/shared/get_subunits.py,sha256=UrU0CpZj3pfHZWI7Uuhv2a_C0JsO8pnVErY0sWGgNdw,4920
@@ -38,15 +42,15 @@ mgnify_pipelines_toolkit/constants/ncrna.py,sha256=a_5hWp446S7BhRbe_JcydFgZM7sgP
 mgnify_pipelines_toolkit/constants/regex_ambiguous_bases.py,sha256=7nEOODQq35y9wx9YnvJuo29oBpwTpXg_kIbf_t7N4TQ,1093
 mgnify_pipelines_toolkit/constants/regex_fasta_header.py,sha256=G-xrc9b8zdmPTaOICD2b3RCVeFAEOVkfRkIfotQ7gek,1193
 mgnify_pipelines_toolkit/constants/tax_ranks.py,sha256=kMq__kOJcbiwsgolkdvb-XLo3WMnJdEXgedjUyMOYjI,1081
-mgnify_pipelines_toolkit/constants/thresholds.py,sha256=guDE7c4KrVJEfg_AcO_cQoJM6LGGaRlmo_U2i8d4N7g,1157
+mgnify_pipelines_toolkit/constants/thresholds.py,sha256=V_xDBk0RhS3hHeWqOacKzth2gM6zJABRPgwHy-Ciqfk,1157
 mgnify_pipelines_toolkit/constants/var_region_coordinates.py,sha256=0bM4MwarFiM5yTcp5AbAmQ0o-q-gWy7kknir9zJ9R0A,1312
 mgnify_pipelines_toolkit/schemas/schemas.py,sha256=pnH8LUH8i2ACNvFNWyG-n-eIHZcI5O9UDYulkh43mec,7692
 mgnify_pipelines_toolkit/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mgnify_pipelines_toolkit/utils/fasta_to_delimited.py,sha256=lgYIR1S4crURY7C7nFtgE6QMV4u4zCNsUrVkcRnsEEo,3996
 mgnify_pipelines_toolkit/utils/get_mpt_version.py,sha256=aS9bWrC9CP7tpxoEVg6eEYt18-pmjG7fJl5Mchz4YOU,798
-mgnify_pipelines_toolkit-1.0.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mgnify_pipelines_toolkit-1.0.4.dist-info/METADATA,sha256=Coky89dC0Xh5wHLk7fPGEOk_-fXY3GvvMMtb2dz5krc,5810
-mgnify_pipelines_toolkit-1.0.4.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-mgnify_pipelines_toolkit-1.0.4.dist-info/entry_points.txt,sha256=QZ6vY4w3lYG8Xmll_s9SIsOpkxa5gBVEIxU3GvoCF4I,2946
-mgnify_pipelines_toolkit-1.0.4.dist-info/top_level.txt,sha256=xA_wC7C01V3VwuDnqwRM2QYeJJ45WtvF6LVav4tYxuE,25
-mgnify_pipelines_toolkit-1.0.4.dist-info/RECORD,,
+mgnify_pipelines_toolkit-1.0.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mgnify_pipelines_toolkit-1.0.6.dist-info/METADATA,sha256=b9Hoo0e0xVvL4erImJgt_7gtbb-5Yx8TZNlf9KZcQIY,5810
+mgnify_pipelines_toolkit-1.0.6.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+mgnify_pipelines_toolkit-1.0.6.dist-info/entry_points.txt,sha256=T8soGT2to8c_qafw-0itqCn4sjOnxlfaNWHIaHz4H54,3416
+mgnify_pipelines_toolkit-1.0.6.dist-info/top_level.txt,sha256=xA_wC7C01V3VwuDnqwRM2QYeJJ45WtvF6LVav4tYxuE,25
+mgnify_pipelines_toolkit-1.0.6.dist-info/RECORD,,

{mgnify_pipelines_toolkit-1.0.4.dist-info → mgnify_pipelines_toolkit-1.0.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{mgnify_pipelines_toolkit-1.0.4.dist-info → mgnify_pipelines_toolkit-1.0.6.dist-info}/entry_points.txt

@@ -18,6 +18,7 @@ genomes_extract_trnas = mgnify_pipelines_toolkit.analysis.genomes.rna.extract_tr
 get_mpt_version = mgnify_pipelines_toolkit.utils.get_mpt_version:main
 get_subunits = mgnify_pipelines_toolkit.analysis.shared.get_subunits:main
 get_subunits_coords = mgnify_pipelines_toolkit.analysis.shared.get_subunits_coords:main
+gff_toolkit = mgnify_pipelines_toolkit.analysis.assembly.gff_toolkit:main
 krona_txt_from_cat_classification = mgnify_pipelines_toolkit.analysis.assembly.krona_txt_from_cat_classification:main
 library_strategy_check = mgnify_pipelines_toolkit.analysis.shared.library_strategy_check:main
 make_asv_count_table = mgnify_pipelines_toolkit.analysis.amplicon.make_asv_count_table:main
@@ -25,8 +26,12 @@ mapseq2biom = mgnify_pipelines_toolkit.analysis.shared.mapseq2biom:main
 mapseq_to_asv_table = mgnify_pipelines_toolkit.analysis.amplicon.mapseq_to_asv_table:main
 markergene_study_summary = mgnify_pipelines_toolkit.analysis.shared.markergene_study_summary:main
 primer_val_classification = mgnify_pipelines_toolkit.analysis.amplicon.primer_val_classification:main
+process_dbcan_cazys = mgnify_pipelines_toolkit.analysis.assembly.process_dbcan_result_cazys:main
+process_dbcan_clusters = mgnify_pipelines_toolkit.analysis.assembly.process_dbcan_result_clusters:main
 remove_ambiguous_reads = mgnify_pipelines_toolkit.analysis.amplicon.remove_ambiguous_reads:main
 rev_comp_se_primers = mgnify_pipelines_toolkit.analysis.amplicon.rev_comp_se_primers:main
 standard_primer_matching = mgnify_pipelines_toolkit.analysis.amplicon.standard_primer_matching:main
 study_summary_generator = mgnify_pipelines_toolkit.analysis.shared.study_summary_generator:cli
+summarise_antismash_bgcs = mgnify_pipelines_toolkit.analysis.assembly.summarise_antismash_bgcs:main
 summarise_goslims = mgnify_pipelines_toolkit.analysis.assembly.summarise_goslims:main
+summarise_sanntis_bgcs = mgnify_pipelines_toolkit.analysis.assembly.summarise_sanntis_bgcs:main