mgnify-pipelines-toolkit 1.2.5__tar.gz → 1.2.7__tar.gz

{mgnify_pipelines_toolkit-1.2.5 → mgnify_pipelines_toolkit-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mgnify_pipelines_toolkit
-Version: 1.2.5
+Version: 1.2.7
 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.2.5 → mgnify_pipelines_toolkit-1.2.7}/mgnify_pipelines_toolkit/analysis/amplicon/classify_var_regions.py

@@ -454,7 +454,7 @@ def retrieve_regions(
                 temp_seq_counter[determine_domain(model) + " " + reg] = (
                     len(model_regions) * freq
                 )
-        if total_useful_sequences / len(data) < 0.95 and run_status != "ambiguous":
+        if total_useful_sequences / len(data) < 0.75 and run_status != "ambiguous":
             failed_run_counter += 1
             logging.info("No output will be produced - too few useful sequences")
             continue

mgnify_pipelines_toolkit-1.2.7/mgnify_pipelines_toolkit/analysis/rawreads/study_summary_generator.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2024-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 shutil
+from shutil import SameFileError
+
+import click
+from collections import defaultdict
+import glob
+import logging
+from pathlib import Path
+from typing import Union, List
+
+import pandas as pd
+
+from mgnify_pipelines_toolkit.constants.db_labels import (
+    RRAP_TAXDB_LABELS,
+    RRAP_FUNCDB_LABELS,
+)
+from mgnify_pipelines_toolkit.constants.tax_ranks import (
+    _SILVA_TAX_RANKS,
+    _MOTUS_TAX_RANKS,
+)
+from mgnify_pipelines_toolkit.schemas.schemas import (
+    RawReadsPassedRunsSchema,
+    RawReadsNonINSDCPassedRunsSchema,
+    TaxonSchema,
+    MotusTaxonSchema,
+    FunctionProfileSchema,
+    validate_dataframe,
+)
+
+logging.basicConfig(level=logging.DEBUG)
+
+
+@click.group()
+def cli():
+    pass
+
+
+def get_file(
+    run_acc: str, analyses_dir: Path, db_label: str
+) -> Union[Path, List[Path]]:
+    """Takes path information for a particular analysis and db_label combo, and returns any existing files.
+
+    :param run_acc: Run accession for the tax file that should be retrieved.
+    :type run_acc: str
+    :param analyses_dir: The path to the directory containing all of the analyses,
+            including the tax file corresponding to :param:`run_acc`.
+    :type analyses_dir: Path
+    :param db_label: One of the database labels that results might exist for,
+            values of which come from the imported constants ``RRAP_TAXDB_LABELS`` and ``RRAP_FUNCDB_LABELS``.
+    :type db_label: str
+    :return: A :class:`Path` object if :param:`db_label` comes from ``RRAP_TAXDB_LABELS`` or ``RRAP_FUNCDB_LABELS``.
+    :rtype: Union[Path, List[Path]]
+    """
+
+    if db_label not in RRAP_TAXDB_LABELS + RRAP_FUNCDB_LABELS:
+        return
+
+    if db_label in RRAP_TAXDB_LABELS:
+        db_dir = "taxonomy-summary"
+    else:
+        db_dir = "function-summary"
+    db_path = Path(f"{analyses_dir}/{run_acc}/{db_dir}/{db_label}")
+
+    if not db_path.exists():
+        logging.debug(
+            f"DB {db_path} doesn't exist for {run_acc}. Skipping"
+        )  # or error?
+        return
+
+    analysis_file = Path(
+        f"{analyses_dir}/{run_acc}/{db_dir}/{db_label}/{run_acc}_{db_label}.txt"
+    )
+    if not analysis_file.exists():
+        logging.error(
+            f"DB path exists but file doesn't - exiting. Path: {analysis_file}"
+        )
+        exit(1)
+
+    file_size = analysis_file.stat().st_size
+    if (
+        file_size == 0
+    ):  # Pipeline can generate files that are empty for ITS DBs (UNITE and ITSoneDB),
+        # so need to skip those. Should probably fix that at some point
+        logging.debug(
+            f"File {analysis_file} exists but is empty, so will be skipping it."
+        )
+        analysis_file = None
+
+    return analysis_file
+
+
+def parse_one_tax_file(run_acc: str, tax_file: Path, db_label: str) -> pd.DataFrame:
+    """Parses a taxonomy file, and returns it as a pandas DataFrame object.
+
+    :param run_acc: Run accession of the taxonomy file that will be parsed.
+    :type run_acc: str
+    :param tax_file: Taxonomy file that will be parsed.
+    :type tax_file: Path
+    :param db_label: One of the database labels that results might exist for,
+        values of which come from the imported constants ``RRAP_TAXDB_LABELS` and `RRAP_FUNCDB_LABELS``.
+    :type db_label: str
+    :return: The parsed :param:`tax_file` as a :class:`pd.DataFrame` object
+    :rtype: pd.DataFrame
+    """
+
+    tax_ranks = _MOTUS_TAX_RANKS if db_label == "mOTUs" else _SILVA_TAX_RANKS
+    res_df = pd.read_csv(tax_file, sep="\t", skiprows=1, names=["Count"] + tax_ranks)
+    res_df = res_df.fillna("")
+
+    validate_dataframe(
+        res_df, MotusTaxonSchema if db_label == "mOTUs" else TaxonSchema, str(tax_file)
+    )
+
+    res_df["full_taxon"] = res_df.iloc[:, 1:].apply(
+        lambda x: ";".join(x).strip(";"), axis=1
+    )
+    final_df = res_df.iloc[:, [0, -1]]
+    final_df = final_df.set_index("full_taxon")
+    final_df.columns = [run_acc]
+
+    return final_df
+
+
+def parse_one_func_file(
+    run_acc: str, func_file: Path, db_label: str
+) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    """Parses a functional profile file, and returns it as a pandas DataFrame object.
+
+    :param run_acc: Run accession of the taxonomy file that will be parsed.
+    :type run_acc: str
+    :param func_file: Functional profile file that will be parsed.
+    :type func_file: Path
+    :param db_label: One of the database labels that results might exist for,
+        values of which come from the imported constants ``RRAP_TAXDB_LABELS` and `RRAP_FUNCDB_LABELS``.
+    :type db_label: str
+    :return: The parsed :param:`func_file` as a :class:`pd.DataFrame` object
+    :rtype: pd.DataFrame
+    """
+
+    res_df = pd.read_csv(
+        func_file,
+        sep="\t",
+        names=["function", "read_count", "coverage_depth", "coverage_breadth"],
+        skiprows=1,
+        dtype={"read_count": int, "coverage_depth": float, "coverage_breadth": float},
+    ).set_index("function")
+    res_df = res_df.fillna(0)
+
+    validate_dataframe(res_df, FunctionProfileSchema, str(func_file))
+
+    count_df = res_df[["read_count"]]
+    count_df.columns = [run_acc]
+
+    depth_df = res_df[["coverage_depth"]]
+    depth_df.columns = [run_acc]
+
+    breadth_df = res_df[["coverage_breadth"]]
+    breadth_df.columns = [run_acc]
+
+    return count_df, depth_df, breadth_df
+
+
+def generate_db_summary(
+    db_label: str, analysis_dfs: dict[str, Path], output_prefix: str
+) -> None:
+    """Takes paired run accessions taxonomy dataframes in the form of a dictionary,
+    and respective db_label, joins them together, and generates a study-wide summary
+    in the form of a .tsv file.
+
+    :param db_label: One of the database labels that results might exist for,
+            values of which come from the imported constants ``RRAP_TAXDB_LABELS` and `RRAP_FUNCDB_LABELS``.
+    :param tax_dfs: Dictionary where the key is a run accession,
+        and values are one parsed taxonomy dataframe if the :param:db_label comes from ``RRAP_TAXDB_LABELS` or `RRAP_FUNCDB_LABELS``.
+        These dataframes are parsed by :func:`parse_one_tax_file` or `parse_one_func_file`.
+    :type tax_dfs: defaultdict[Path]
+    :param output_prefix: Prefix to be added to the generated summary file.
+    :type output_prefix: str
+    """
+
+    if db_label in RRAP_TAXDB_LABELS:
+        df_list = []
+
+        for run_acc, analysis_df in analysis_dfs.items():
+            res_df = parse_one_tax_file(run_acc, analysis_df, db_label)
+            df_list.append(res_df)
+
+        res_df = pd.concat(df_list, axis=1).fillna(0)
+        res_df = res_df.sort_index()
+        res_df = res_df.astype(int)
+
+        res_df.to_csv(
+            f"{output_prefix}_{db_label}_study_summary.tsv",
+            sep="\t",
+            index_label="taxonomy",
+        )
+
+    if db_label in RRAP_FUNCDB_LABELS:
+        count_df_list = []
+        depth_df_list = []
+        breadth_df_list = []
+
+        for run_acc, analysis_df in analysis_dfs.items():
+            count_df, depth_df, breadth_df = parse_one_func_file(
+                run_acc, analysis_df, db_label
+            )
+            count_df_list.append(count_df)
+            depth_df_list.append(depth_df)
+            breadth_df_list.append(breadth_df)
+
+        count_df = pd.concat(count_df_list, axis=1).fillna(0)
+        count_df = count_df.sort_index()
+        count_df = count_df.astype(int)
+
+        count_df.to_csv(
+            f"{output_prefix}_{db_label}_read-count_study_summary.tsv",
+            sep="\t",
+            index_label="function",
+        )
+
+        depth_df = pd.concat(depth_df_list, axis=1).fillna(0)
+        depth_df = depth_df.sort_index()
+        depth_df = depth_df.astype(float)
+
+        depth_df.to_csv(
+            f"{output_prefix}_{db_label}_coverage-depth_study_summary.tsv",
+            sep="\t",
+            index_label="function",
+            float_format="%.6g",
+        )
+
+        breadth_df = pd.concat(breadth_df_list, axis=1).fillna(0)
+        breadth_df = breadth_df.sort_index()
+        breadth_df = breadth_df.astype(float)
+
+        breadth_df.to_csv(
+            f"{output_prefix}_{db_label}_coverage-breadth_study_summary.tsv",
+            sep="\t",
+            index_label="function",
+            float_format="%.6g",
+        )
+
+
+def organise_study_summaries(all_study_summaries: List[str]) -> defaultdict[str, List]:
+    """Matches different summary files of the same database label and analysis
+    type into a dictionary to help merge
+    the correct summaries.
+
+    :param all_study_summaries: List of file paths to different summary files
+    :type all_study_summaries: List[str]
+    :return: Organised dictionary where each summary is paired to a specific
+        database label key to be merged together.
+    :rtype: defaultdict[List]
+    """
+    summaries_dict = defaultdict(list)
+
+    for summary in all_study_summaries:
+        summary_path = Path(summary)
+        summary_filename = summary_path.stem
+
+        summary_db_label = summary_filename.split("_")[1]
+
+        summaries_dict[summary_db_label].append(summary_path)
+
+    return summaries_dict
+
+
+@cli.command(
+    "summarise",
+    options_metavar="-r <runs> -a <analyses_dir> -p <output_prefix>",
+    short_help="Generate study-level summaries of raw-read analysis results.",
+)
+@click.option(
+    "-r",
+    "--runs",
+    required=True,
+    help="CSV file containing successful analyses generated by the pipeline",
+    type=click.Path(exists=True, path_type=Path, dir_okay=False),
+)
+@click.option(
+    "-a",
+    "--analyses_dir",
+    required=True,
+    help="Input directory to where all the individual analyses subdirectories for summarising",
+    type=click.Path(exists=True, path_type=Path, file_okay=False),
+)
+@click.option(
+    "-p", "--output_prefix", required=True, help="Prefix to summary files", type=str
+)
+@click.option(
+    "--non_insdc",
+    default=False,
+    is_flag=True,
+    help="If run accessions aren't INSDC-formatted",
+)
+def summarise_analyses(
+    runs: Path, analyses_dir: Path, output_prefix: str, non_insdc: bool
+) -> None:
+    """Function that will take a file of pipeline-successful run accessions
+    that should be used for the generation of the relevant db-specific
+    study-level summary files.
+    \f
+
+    :param runs: Path to a qc_passed_runs file from the pipeline execution.
+        Contains the accessions of runs that should therefore be included in the generated
+        summaries.
+    :type runs: Path
+    :param analyses_dir: The path to the directory containing all of the analyses.
+    :type analyses_dir: Path
+    :param output_prefix: Prefix to be added to the generated summary file.
+    :type output_prefix: str
+    """
+    runs_df = pd.read_csv(runs, names=["run", "status"])
+
+    if not non_insdc:
+        RawReadsPassedRunsSchema(
+            runs_df
+        )  # Run validation on the successful_runs .csv file
+    else:
+        RawReadsNonINSDCPassedRunsSchema(runs_df)
+
+    all_db_labels = RRAP_TAXDB_LABELS + RRAP_FUNCDB_LABELS
+    for db_label in all_db_labels:
+
+        analysis_files = {}
+        for run_acc in runs_df["run"]:
+            analysis_file = get_file(run_acc, analyses_dir, db_label)
+
+            if analysis_file:
+                analysis_files[run_acc] = analysis_file
+
+        if analysis_files:
+            generate_db_summary(db_label, analysis_files, output_prefix)
+
+
+@cli.command(
+    "merge",
+    options_metavar="-a <analyses_dir> -p <output_prefix>",
+    short_help="Merge multiple study-level summaries of raw-read analysis.",
+)
+@click.option(
+    "-a",
+    "--analyses_dir",
+    required=True,
+    help="Input directory to where all the individual analyses subdirectories for merging",
+    type=click.Path(exists=True, file_okay=False),
+)
+@click.option(
+    "-p",
+    "--output_prefix",
+    required=True,
+    help="Prefix to merged summary files",
+    type=str,
+)
+def merge_summaries(analyses_dir: str, output_prefix: str) -> None:
+    """Function that will take a file path containing study-level
+    summaries that should be merged together on a per-db
+    basis.
+    \f
+
+    :param analyses_dir: The filepath to the directory containing all of the analyses.
+    :type analyses_dir: str
+    :param output_prefix: Prefix to be added to the generated summary file.
+    :type output_prefix: str
+    """
+
+    all_study_summaries = glob.glob(f"{analyses_dir}/*_study_summary.tsv")
+
+    summaries_dict = organise_study_summaries(all_study_summaries)
+
+    for db_label, summaries in summaries_dict.items():
+        if db_label in RRAP_TAXDB_LABELS:
+            merged_summary_name = f"{output_prefix}_{db_label}_study_summary.tsv"
+            if len(summaries) > 1:
+                res_df = pd.read_csv(summaries[0], sep="\t", index_col=0)
+                for summary in summaries[1:]:
+                    curr_df = pd.read_csv(summary, sep="\t", index_col=0)
+                    res_df = res_df.join(curr_df, how="outer")
+                    res_df = res_df.fillna(0)
+                    res_df = res_df.astype(int)
+
+                res_df = res_df.reindex(sorted(res_df.columns), axis=1)
+                res_df.to_csv(
+                    merged_summary_name,
+                    sep="\t",
+                    index_label="taxonomy",
+                )
+            elif len(summaries) == 1:
+                logging.info(
+                    f"Only one summary ({summaries[0]}) so will use that as {merged_summary_name}"
+                )
+                try:
+                    shutil.copyfile(summaries[0], merged_summary_name)
+                except SameFileError:
+                    pass
+
+        if db_label in RRAP_FUNCDB_LABELS:
+            for table_type in ["read-count", "coverage-depth", "coverage-breadth"]:
+                merged_summary_name = (
+                    f"{output_prefix}_{db_label}_{table_type}_study_summary.tsv"
+                )
+                summaries_ = [
+                    v for v in summaries if Path(v).stem.split("_")[2] == table_type
+                ]
+                if len(summaries_) > 1:
+                    res_df = pd.read_csv(summaries_[0], sep="\t", index_col=0)
+                    for summary in summaries_[1:]:
+                        curr_df = pd.read_csv(summary, sep="\t", index_col=0)
+                        res_df = res_df.join(curr_df, how="outer")
+                        res_df = res_df.fillna(0)
+                        res_df = res_df.astype(int if table_type == "count" else float)
+
+                    res_df = res_df.reindex(sorted(res_df.columns), axis=1)
+                    res_df.to_csv(
+                        merged_summary_name,
+                        sep="\t",
+                        index_label="function",
+                        float_format="%.6g",
+                    )
+                elif len(summaries_) == 1:
+                    logging.info(
+                        f"Only one summary ({summaries_[0]}) so will use that as {merged_summary_name}"
+                    )
+                    try:
+                        shutil.copyfile(summaries_[0], merged_summary_name)
+                    except SameFileError:
+                        pass
+
+
+if __name__ == "__main__":
+    cli()

{mgnify_pipelines_toolkit-1.2.5 → mgnify_pipelines_toolkit-1.2.7}/mgnify_pipelines_toolkit/constants/db_labels.py

@@ -19,3 +19,9 @@ TAXDB_LABELS = ["SILVA-SSU", "SILVA-LSU", "PR2", "UNITE", "ITSoneDB"]
 
 # taxonomy_summary for ASV method
 ASV_TAXDB_LABELS = ["DADA2-SILVA", "DADA2-PR2"]
+
+# taxonomy_summary labels for Raw Reads Analysis Pipeline
+RRAP_TAXDB_LABELS = ['SILVA-SSU', 'SILVA-LSU', 'mOTUs']
+
+# function_summary labels for Raw Reads Analysis Pipeline
+RRAP_FUNCDB_LABELS = ['Pfam-A']

{mgnify_pipelines_toolkit-1.2.5 → mgnify_pipelines_toolkit-1.2.7}/mgnify_pipelines_toolkit/constants/tax_ranks.py

@@ -35,7 +35,16 @@ _PR2_TAX_RANKS = [
     "Genus",
     "Species",
 ]
+_MOTUS_TAX_RANKS = [
+    'Kingdom',
+    'Phylum',
+    'Class',
+    'Order',
+    'Family',
+    'Genus',
+    'Species'
+]
 
 SHORT_TAX_RANKS = ["sk", "k", "p", "c", "o", "f", "g", "s"]
-
+SHORT_MOTUS_TAX_RANKS = ["k", "p", "c", "o", "f", "g", "s"]
 SHORT_PR2_TAX_RANKS = ["d", "sg", "dv", "sdv", "c", "o", "f", "g", "s"]

{mgnify_pipelines_toolkit-1.2.5 → mgnify_pipelines_toolkit-1.2.7}/mgnify_pipelines_toolkit/schemas/schemas.py

@@ -16,7 +16,7 @@
 import logging
 import re
 
-from enum import Enum
+from enum import StrEnum
 from typing import ClassVar, Optional, Type, Literal
 
 import pandas as pd
@@ -35,6 +35,7 @@ from pandera.engines.pandas_engine import PydanticModel
 from mgnify_pipelines_toolkit.constants.tax_ranks import (
     SHORT_TAX_RANKS,
     SHORT_PR2_TAX_RANKS,
+    SHORT_MOTUS_TAX_RANKS,
 )
 
 
@@ -70,7 +71,7 @@ class INSDCRunAccession(RootModel):
         return run
 
 
-class AmpliconResultTypes(str, Enum):
+class AmpliconResultTypes(StrEnum):
     """Class that models the two allowed statuses for successful amplicon analysis runs.
     Pydantic validates Enums very simply without needing to declare a new function.
     """
@@ -545,7 +546,7 @@ class TaxonRecord(Taxon):
 class PR2TaxonRecord(PR2Taxon):
     """Class for modelling the same thing as the preceding class, but for PR2 ranks."""
 
-    Count: int
+    count: int = Field(alias="Count")
 
 
 # This is the schema for the whole DF
@@ -573,6 +574,154 @@ class PR2TaxonSchema(pa.DataFrameModel):
         coerce = True
 
 
+class RawReadsStatusTypes(StrEnum):
+    """Class that models the four allowed statuses for successful raw reads analysis runs.
+    Pydantic validates Enums very simply without needing to declare a new function.
+    """
+
+    all_results = "all_results"
+    no_reads = "no_reads"
+    no_results = "no_results"
+    missing_results = "missing_results"
+
+
+class RawReadsPassedRunsRecord(BaseModel):
+    """Class defining a Pydantic model for a single "row" of a raw-reads pipeline passed runs file.
+    Uses the previous nine classes.
+    """
+
+    run: INSDCRunAccession
+    status: RawReadsStatusTypes
+
+
+class RawReadsNonINSDCSPassedRunsRecord(RawReadsPassedRunsRecord):
+    """Class modeling a very similar model as the preceding one, but with no INSDC-validation.
+    This is achieved by replacing the type of the runs with just a simple string so no validation
+    happens.
+    """
+
+    run: str
+
+
+# This is the schema for the whole DF
+class RawReadsPassedRunsSchema(pa.DataFrameModel):
+    """Class modelling a Pandera dataframe schema that uses the RawReadsPassedRunsRecord class as dtype.
+    This is what actually validates the generated dataframe when read by pandas.read_csv.
+    """
+
+    class Config:
+        """Config with dataframe-level data type."""
+
+        dtype = PydanticModel(RawReadsPassedRunsRecord)
+        coerce = True
+
+
+class RawReadsNonINSDCPassedRunsSchema(pa.DataFrameModel):
+    """Class modelling the same dataframe schema as the preceding one, except with no INSDC validation.
+    Uses the RawReadsNonINSDCSPassedRunsRecord as a dtype to achieve this.
+    """
+
+    class Config:
+        """Config with dataframe-level data type."""
+
+        dtype = PydanticModel(RawReadsNonINSDCSPassedRunsRecord)
+        coerce = True
+
+
+class MotusTaxRank(RootModel):
+    """Class for modelling a single Taxonomic Rank in mOTUs output.
+    Essentially is just a special string with validation of the structure:
+    `${rank}__${taxon}`
+    Where `${rank}` is one of the allowed short ranks defined by the imported
+    `SHORT_MOTUS_TAX_RANKS` variables.
+    And `${taxon}` is the actual taxon for that rank (this isn't validated).
+    It will also validate if the whole string is the permitted "unassigned" or "unclassified".
+    """
+
+    valid_tax_ranks: ClassVar = SHORT_MOTUS_TAX_RANKS
+
+    root: str = Field(
+        unique=True,
+        description="A single taxon in a taxonomy record",
+        examples=["sk__Bacteria", "p__Bacillota", "g__Tundrisphaera"],
+    )
+
+    @field_validator("root", mode="after")
+    @classmethod
+    def rank_structure_validity_check(cls, taxrank: str) -> bool:
+        taxrank_list = taxrank.split("__")
+        rank = taxrank_list[0]
+        if (
+            rank != ""
+            and not rank.capitalize() in {"Unclassified", "Unassigned"}
+            and rank not in cls.valid_tax_ranks
+        ):
+            raise ValueError(f"Invalid taxonomy rank {rank}.")
+
+        return taxrank
+
+
+class MotusTaxon(BaseModel):
+    """Class for modelling an entire MotusTaxon or mOTUs taxonomic assignment.
+    All of the ranks are optional, to model for the taxon being "Unclassified" or "Unassigned".
+    """
+
+    Kingdom: Optional[MotusTaxRank] = None
+    Phylum: Optional[MotusTaxRank] = None
+    Class: Optional[MotusTaxRank] = None
+    Order: Optional[MotusTaxRank] = None
+    Family: Optional[MotusTaxRank] = None
+    Genus: Optional[MotusTaxRank] = None
+    Species: Optional[MotusTaxRank] = None
+
+
+class MotusTaxonRecord(MotusTaxon):
+    """Class for modelling a single taxon record in a mOTUs taxonomy file.
+    It inherits the MotusTaxon class, and simply adds a Count field, modelling the read counts
+    for that particular MotusTaxon record.
+    """
+
+    count: int = Field(alias="Count")
+
+
+class MotusTaxonSchema(pa.DataFrameModel):
+    """Class modelling a Pandera dataframe schema that uses the MotusTaxonRecord class as dtype.
+    This is what actually validates the generated dataframe when read by pandas.read_csv.
+    """
+
+    class Config:
+        """Config with dataframe-level data type."""
+
+        dtype = PydanticModel(MotusTaxonRecord)
+        coerce = True
+
+
+class FunctionProfileRecord(BaseModel):
+    """Class for modelling a single taxon record in a functional profile file.
+    It models the read counts and coverage depth/breadth of each function (gene/protein)
+    for each specific record.
+    """
+
+    read_count: int
+    coverage_depth: float
+    coverage_breadth: float
+
+    class Config:
+        validate_by_name = True
+
+
+class FunctionProfileSchema(pa.DataFrameModel):
+    """Class modelling a Pandera dataframe schema that uses the FunctionProfileRecord class as dtype.
+    This is what actually validates the generated dataframe when read by pandas.read_csv.
+    """
+
+    class Config:
+        """Config with dataframe-level data type."""
+
+        dtype = PydanticModel(FunctionProfileRecord)
+        coerce = True
+
+
 def validate_dataframe(
     df: pd.DataFrame, schema: Type[pa.DataFrameModel], df_metadata: str
 ) -> DataFrameBase:

{mgnify_pipelines_toolkit-1.2.5 → mgnify_pipelines_toolkit-1.2.7}/mgnify_pipelines_toolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mgnify_pipelines_toolkit
-Version: 1.2.5
+Version: 1.2.7
 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.2.5 → mgnify_pipelines_toolkit-1.2.7}/mgnify_pipelines_toolkit.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ mgnify_pipelines_toolkit/analysis/assembly/summarise_antismash_bgcs.py
 mgnify_pipelines_toolkit/analysis/assembly/summarise_goslims.py
 mgnify_pipelines_toolkit/analysis/assembly/summarise_sanntis_bgcs.py
 mgnify_pipelines_toolkit/analysis/genomes/__init__.py
+mgnify_pipelines_toolkit/analysis/rawreads/study_summary_generator.py
 mgnify_pipelines_toolkit/analysis/shared/__init__.py
 mgnify_pipelines_toolkit/analysis/shared/convert_cmscan_to_cmsearch_tblout.py
 mgnify_pipelines_toolkit/analysis/shared/dwc_summary_generator.py

{mgnify_pipelines_toolkit-1.2.5 → mgnify_pipelines_toolkit-1.2.7}/mgnify_pipelines_toolkit.egg-info/entry_points.txt

@@ -27,6 +27,7 @@ permute_primers = mgnify_pipelines_toolkit.analysis.amplicon.permute_primers:mai
 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
+rawreads_study_summary_generator = mgnify_pipelines_toolkit.analysis.rawreads.study_summary_generator:cli
 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
 summarise_antismash_bgcs = mgnify_pipelines_toolkit.analysis.assembly.summarise_antismash_bgcs:main

{mgnify_pipelines_toolkit-1.2.5 → mgnify_pipelines_toolkit-1.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mgnify_pipelines_toolkit"
-version = "1.2.5"
+version = "1.2.7"
 readme = "README.md"
 license = { text = "Apache Software License 2.0" }
 authors = [
@@ -39,7 +39,8 @@ packages = ["mgnify_pipelines_toolkit",
     "mgnify_pipelines_toolkit.analysis.shared",
     "mgnify_pipelines_toolkit.analysis.amplicon",
     "mgnify_pipelines_toolkit.analysis.assembly",
-    "mgnify_pipelines_toolkit.analysis.genomes"
+    "mgnify_pipelines_toolkit.analysis.genomes",
+    "mgnify_pipelines_toolkit.analysis.rawreads",
 ]
 
 [project.scripts]
@@ -74,6 +75,8 @@ summarise_antismash_bgcs = "mgnify_pipelines_toolkit.analysis.assembly.summarise
 gff_toolkit = "mgnify_pipelines_toolkit.analysis.assembly.gff_toolkit:main"
 process_dbcan_clusters = "mgnify_pipelines_toolkit.analysis.assembly.process_dbcan_result_clusters:main"
 process_dbcan_cazys = "mgnify_pipelines_toolkit.analysis.assembly.process_dbcan_result_cazys:main"
+# analysis.rawreads #
+rawreads_study_summary_generator = "mgnify_pipelines_toolkit.analysis.rawreads.study_summary_generator:cli"
 # genomes #
 genomes_extract_bacterial_rrnas_as_tsv = "mgnify_pipelines_toolkit.analysis.genomes.rna.extract_bacterial_rrnas_as_tsv:main"
 genomes_extract_rrnas_as_fasta = "mgnify_pipelines_toolkit.analysis.genomes.rna.extract_rrnas_as_fasta:main"