mgnify-pipelines-toolkit 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

mgnify_pipelines_toolkit/analysis/assembly/process_dbcan_result_clusters.py

@@ -0,0 +1,162 @@
+#!/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(standard_file, substrate_file, outfile, dbcan_version):
+    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_version, 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__":
+    args = parse_args()
+    main(args.standard_file, args.substrate_file, args.outfile, args.dbcan_ver)

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/analysis/shared/get_subunits.py

@@ -108,7 +108,7 @@ def main():
 
     open_files = {}
     for record in SeqIO.parse(args.input, "fasta"):
-        model = "-".join(record.id.split("/")[0].split("-")[-1:])
+        model = "-".join("/".join(record.id.split("/")[:-1]).split("-")[-1:])
         if model in SSU_MODELS:
             if SSU not in open_files:
                 file_out = open(pattern_dict[SSU], "w")

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.3.dist-info → mgnify_pipelines_toolkit-1.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mgnify_pipelines_toolkit
-Version: 1.0.3
+Version: 1.0.5
 Summary: Collection of scripts and tools for MGnify pipelines
 Author-email: MGnify team <metagenomics-help@ebi.ac.uk>
 License: Apache Software License 2.0
@@ -11,33 +11,24 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: biopython==1.82
-Requires-Dist: numpy==1.26.0
-Requires-Dist: pandas==2.0.2
-Requires-Dist: regex==2023.12.25
-Requires-Dist: requests==2.32.3
-Requires-Dist: click==8.1.7
-Requires-Dist: pandera==0.22.1
-Requires-Dist: pyfastx>=2.2.0
-Requires-Dist: intervaltree==3.1.0
+Requires-Dist: biopython>=1.85
+Requires-Dist: numpy<3,>=2.2.4
+Requires-Dist: pandas<3,>=2.2.3
+Requires-Dist: regex>=2024.11.6
+Requires-Dist: requests<3,>=2.32.3
+Requires-Dist: click<9,>=8.1.8
+Requires-Dist: pandera<0.24,>=0.23.1
+Requires-Dist: pyfastx<3,>=2.2.0
+Requires-Dist: intervaltree<4,>=3.1.0
 Provides-Extra: tests
-Requires-Dist: pytest==7.4.0; extra == "tests"
-Requires-Dist: pytest-md==0.2.0; extra == "tests"
-Requires-Dist: pytest-workflow==2.0.1; extra == "tests"
-Requires-Dist: biopython==1.82; extra == "tests"
-Requires-Dist: pandas==2.0.2; extra == "tests"
-Requires-Dist: numpy==1.26.0; extra == "tests"
-Requires-Dist: regex==2023.12.25; extra == "tests"
-Requires-Dist: requests==2.32.3; extra == "tests"
-Requires-Dist: click==8.1.7; extra == "tests"
-Requires-Dist: pandera==0.22.1; extra == "tests"
-Requires-Dist: pyfastx>=2.2.0; extra == "tests"
+Requires-Dist: pytest<9,>=8.3.5; extra == "tests"
+Requires-Dist: pytest-md>=0.2.0; extra == "tests"
+Requires-Dist: pytest-workflow==2.1.0; extra == "tests"
 Provides-Extra: dev
-Requires-Dist: mgnify_pipelines_toolkit[tests]; extra == "dev"
-Requires-Dist: pre-commit==3.8.0; extra == "dev"
-Requires-Dist: black==24.8.0; extra == "dev"
-Requires-Dist: flake8==7.1.1; extra == "dev"
-Requires-Dist: pep8-naming==0.14.1; extra == "dev"
+Requires-Dist: pre-commit>=4.2.0; extra == "dev"
+Requires-Dist: black>=25.1.0; extra == "dev"
+Requires-Dist: flake8>=7.1.2; extra == "dev"
+Requires-Dist: pep8-naming>=0.14.1; extra == "dev"
 Dynamic: license-file
 
 # mgnify-pipelines-toolkit
@@ -74,8 +65,9 @@ Before starting any development, you should do these few steps:
 - Clone the repo if you haven't already and create a feature branch from the `dev` branch (NOT `main`).
 - Create a virtual environment with the tool of your choice (i.e. `conda create --name my_new_env`)
 - Activate you new environment (i.e. `conda activate my_new_env`)
-- Install dev dependencies `pip install -e '.[dev]'`
+- Install dev dependencies `pip install -e '.[tests,dev]'`
 - Install pre-commit hooks `pre-commit install`
+- Run unit tests `pytest`
 
 When doing these steps above, you ensure that the code you add will be linted and formatted properly.