meta_eukaryome_detect 0.1.0__tar.gz

meta_eukaryome_detect-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023, Anthony Fullam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

meta_eukaryome_detect-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.1
+Name: meta_eukaryome_detect
+Version: 0.1.0
+Summary: Pathogen, Parasite, Eukaryote and Virus detection in metagenomes..
+Home-page: https://git.embl.de/grp-bork/meta-eukaryome-detect
+License: MIT
+Author: Anthony Fullam
+Author-email: anthony.fullam@embl.de
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: dev
+Provides-Extra: doc
+Provides-Extra: test
+Requires-Dist: black (>=23.10.1,<24.0.0) ; extra == "test"
+Requires-Dist: bump2version (>=1.0.1,<2.0.0) ; extra == "dev"
+Requires-Dist: flake8 (>=3.9.2,<4.0.0) ; extra == "test"
+Requires-Dist: flake8-docstrings (>=1.6.0,<2.0.0) ; extra == "test"
+Requires-Dist: flask (>=3.0.0,<4.0.0)
+Requires-Dist: isort (>=5.8.0,<6.0.0) ; extra == "test"
+Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: mkdocs (>=1.5.3,<2.0.0) ; extra == "doc"
+Requires-Dist: mkdocs-autorefs (>=0.5.0,<0.6.0) ; extra == "doc"
+Requires-Dist: mkdocs-include-markdown-plugin (>=6.0.3,<7.0.0) ; extra == "doc"
+Requires-Dist: mkdocs-material (>=6.1.7,<7.0.0) ; extra == "doc"
+Requires-Dist: mkdocs-material-extensions (>=1.0.1,<2.0.0)
+Requires-Dist: mkdocstrings (>=0.23.0,<0.24.0) ; extra == "doc"
+Requires-Dist: mkdocstrings-python (>=1.7.3,<2.0.0)
+Requires-Dist: mypy (>=0.900,<0.901) ; extra == "test"
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pip (>=20.3.1,<21.0.0) ; extra == "dev"
+Requires-Dist: pre-commit (>=2.12.0,<3.0.0) ; extra == "dev"
+Requires-Dist: pytest (>=6.2.4,<7.0.0) ; extra == "test"
+Requires-Dist: pytest-cov (>=2.12.0,<3.0.0) ; extra == "test"
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: toml (>=0.10.2,<0.11.0) ; extra == "dev"
+Requires-Dist: tox (>=3.20.1,<4.0.0) ; extra == "dev"
+Requires-Dist: twine (>=3.3.0,<4.0.0) ; extra == "dev"
+Requires-Dist: types-requests (>=2.31.0.10,<3.0.0.0)
+Requires-Dist: virtualenv (>=20.2.2,<21.0.0) ; extra == "dev"
+Description-Content-Type: text/markdown
+
+# meta-eukaryome-detect
+
+
+[![pypi](https://img.shields.io/pypi/v/meta-eukaryome-detect.svg)](https://pypi.org/project/meta-eukaryome-detect/)
+[![licence](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+Pathogen, Parasite, Eukaryote and Virus detection in metagenomes.
+
+
+* Documentation: <https://grp-bork.embl-community.io/grp-microbiome-astrology/meta_eukaryome_detect/>
+* GitHub: <https://git.embl.de/grp-bork/meta_eukaryome_detect>
+* PyPI: <https://pypi.org/project/meta-eukaryome-detect/>
+* Free software: MIT
+

meta_eukaryome_detect-0.1.0/README.md

@@ -0,0 +1,14 @@
+# meta-eukaryome-detect
+
+
+[![pypi](https://img.shields.io/pypi/v/meta-eukaryome-detect.svg)](https://pypi.org/project/meta-eukaryome-detect/)
+[![licence](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+Pathogen, Parasite, Eukaryote and Virus detection in metagenomes.
+
+
+* Documentation: <https://grp-bork.embl-community.io/grp-microbiome-astrology/meta_eukaryome_detect/>
+* GitHub: <https://git.embl.de/grp-bork/meta_eukaryome_detect>
+* PyPI: <https://pypi.org/project/meta-eukaryome-detect/>
+* Free software: MIT

meta_eukaryome_detect-0.1.0/meta_eukaryome_detect/__init__.py

@@ -0,0 +1,5 @@
+"""Top-level package for meta-eukaryome-detect."""
+
+__author__ = """Anthony Fullam"""
+__email__ = 'anthony.fullam@embl.de'
+__version__ = '0.1.0'

meta_eukaryome_detect-0.1.0/meta_eukaryome_detect/create_ngless_template.py

@@ -0,0 +1,61 @@
+import sys
+from pathlib import Path
+
+
+def get_min_identity_pc(reference_type):
+    match reference_type:
+        case 'plastid':
+            return '98'
+        case 'mito':
+            return '96'
+        case 'pr2':
+            return '97'
+        case 'virulence':
+            return '95'
+        case 'viruses':
+            return '95'
+        case _:
+            sys.exit(f'{reference_type} not a valid reference type!')
+
+
+def get_ngless_filtering_template(reference_type: str, temp_dir: Path, result_dir: Path):
+    if reference_type == 'preprocess':
+        return f"""
+ngless "1.1"
+import "mocat" version "0.0"
+input = load_mocat_sample(ARGV[1])
+
+input = preprocess(input, keep_singles=True) using |read|:
+    read = smoothtrim(read, min_quality=20, window=4)
+    if len(read) < 70:
+        discard
+
+write(input, ofile='{temp_dir}/preprocessed/preprocessed.fq' )
+"""
+    else:
+        min_identity_pc = get_min_identity_pc(reference_type)
+        return f"""
+ngless "1.1"
+import "parallel" version "1.0"
+import "mocat" version "0.0"
+import "samtools" version "0.0"
+
+input = load_mocat_sample(ARGV[1])
+
+mapped = map(input, fafile=ARGV[2])
+write(samtools_sort(mapped), ofile='{temp_dir}/{reference_type}_unfiltered.bam' )
+
+mapped = select(mapped) using |mr|:
+    mr = mr.filter(min_match_size=70, min_identity_pc={min_identity_pc}, action={{drop}})
+write(samtools_sort(mapped), ofile='{result_dir}/{reference_type}_filtered.bam' )
+"""
+
+
+def write_templates(out_dir, temp_dir, result_dir):
+    templates = {}
+    for template in ['preprocess', 'plastid', 'mito', 'pr2', 'virulence', 'viruses']:
+        out_file = Path(out_dir) / f'{template}.ngless'
+        templates[template] = out_file
+        with open(out_file, 'w') as f:
+            f.write(get_ngless_filtering_template(template, temp_dir, result_dir))
+    return templates

meta_eukaryome_detect-0.1.0/meta_eukaryome_detect/depth_summary.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+import gzip
+from pathlib import Path
+
+import pandas as pd
+
+output_col_order = {
+    'plastid': [
+        "sample_name",
+        "ref_id",
+        "ref_length",
+        "avgdepth_cov",
+        "breadth_cov",
+        "breadth_fraction",
+        "ani_cluster_id",
+        "full_taxonomy",
+        "bin_names_in_cluster",
+        "organism_groups_all",
+        'eukaryote_type1',
+        'eukaryote_type2',
+        'short_name',
+        'possible_contaminant_in_human_gut',
+        'other_notes',
+        'eukaryote_type3',
+    ],
+    'mito': [
+        "sample_name",
+        "ref_id",
+        "ref_length",
+        "avgdepth_cov",
+        "breadth_cov",
+        "breadth_fraction",
+        "ani_cluster_id",
+        "full_taxonomy",
+        "bin_names_in_cluster",
+        "organism_groups_all",
+        'eukaryote_type1',
+        'eukaryote_type2',
+        'short_name',
+        'possible_contaminant_in_human_gut',
+        'other_notes',
+        'eukaryote_type3',
+    ],
+    'pr2': [
+        "sample_name",
+        "ref_id",
+        "ref_length",
+        "avgdepth_cov",
+        "breadth_cov",
+        "breadth_fraction",
+        "reference_type",
+        "gene_cluster_id",
+    ],
+    'virulence': [
+        "sample_name",
+        "ref_id",
+        "ref_length",
+        "avgdepth_cov",
+        "breadth_cov",
+        "breadth_fraction",
+        "gene_cluster_id",
+        "SpName_x",
+    ],
+    'viruses': [
+        "sample_name",
+        "ref_id",
+        "ref_length",
+        "avgdepth_cov",
+        "breadth_cov",
+        "breadth_fraction",
+        "Species",
+        "Genus",
+        "Family",
+        "Molecule_type",
+        "Host",
+        "Isolation_Source",
+        "Collection_Date",
+        "BioSample",
+        "GenBank_Title",
+    ],
+}
+
+breadth_coverages = {'plastid': 500, 'mito': 500, 'pr2': 100, 'virulence': 50, 'viruses': 100}
+
+metadata_files = {
+    'plastid': 'mito_plastid_metadata',
+    'mito': 'mito_plastid_metadata',
+    'pr2': 'pr2_metadata',
+    'virulence': 'virulence_metadata',
+    'viruses': 'viruses_metadata',
+}
+
+
+def get_depth_summary(out_dir: Path, reference: str, depth_file: Path, DB: Path, sample_name: str):
+    depths = pd.read_csv(depth_file, sep="\t", header=None, usecols=[0, 2], names=["ref_id", "depth_coverage"])
+    out_file = out_dir / f"{reference}.depth_summary.tsv.gz"
+    if len(depths) != 0:
+        output = depths.groupby("ref_id").mean().rename(columns={"depth_coverage": "avgdepth_cov"})
+        output["breadth_cov"] = depths.groupby("ref_id").count()
+        output = output[output["breadth_cov"] > breadth_coverages[reference]].sort_values(
+            by="breadth_cov", ascending=False
+        )
+
+        contigLen = pd.read_csv(
+            DB / metadata_files[reference],
+            sep="\t",
+            header=0,
+        )
+        output = pd.merge(output, contigLen, how="left", left_index=True, right_on=["ref_id"])
+
+        output["breadth_fraction"] = output["breadth_cov"] / output["ref_length"]
+        output["sample_name"] = sample_name
+        output[output_col_order[reference]].round(4).to_csv(out_file, sep="\t", index=False, compression="gzip")
+
+    else:
+        with gzip.open(out_file, "wb") as f:
+            f.write("\t".join(output_col_order[reference]).encode())

meta_eukaryome_detect-0.1.0/meta_eukaryome_detect/external_tools.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+def check_if_tool_exists(tool_name):
+    """Check if tool is available."""
+    return shutil.which(tool_name) is not None
+
+
+def ngless(template: Path, cpu_count: str, temp_dir: Path, sample_folder: Path, verbose: bool, DB_path='') -> None:
+    """Run ngless.
+
+    Arguments:
+        template (Path): full path of gene calls
+        cpu_count (str): number of threads to use
+        temp_dir (Path): path of directory to use for tmp files
+        sample_folder (Path): full path ti sample directory
+        verbose (bool): Verbose output
+        DB_path (str): Path to directory containing metaeuk db
+
+    """
+    if verbose:
+        ngless_verbosity = '--trace'
+    else:
+        ngless_verbosity = ''
+    try:
+        subprocess.check_output(
+            [
+                "ngless",
+                "--temporary-directory",
+                temp_dir,
+                template,
+                "--jobs",
+                cpu_count,
+                sample_folder,
+                DB_path,
+                ngless_verbosity,
+            ],
+            universal_newlines=True,
+        )
+    except subprocess.CalledProcessError as e:
+        sys.exit(f"[ERROR] Failed to run ngless on {sample_folder} \n {e.output}")
+
+
+def samtools_unique(filtered_bam: Path, unique_bam: Path, min_map_qual: str, verbose: bool) -> None:
+    """
+    Run samtools unique.
+
+    Arguments:
+
+    """
+    try:
+        subprocess.check_output(
+            [
+                "samtools",
+                "view",
+                "-bq",
+                min_map_qual,
+                filtered_bam,
+                "-o",
+                unique_bam,
+            ],
+            universal_newlines=True,
+        )
+    except subprocess.CalledProcessError as e:
+        sys.exit(f"[ERROR] Failed to run samtools view on {filtered_bam} \n {e.output}")
+
+
+def samtools_depth(unique_bam: Path, unique_depth: Path, verbose: bool) -> None:
+    """Run samtools.
+
+    Arguments:
+
+    """
+    try:
+        subprocess.check_output(
+            [
+                "samtools",
+                "depth",
+                unique_bam,
+                "-o",
+                unique_depth,
+            ],
+            universal_newlines=True,
+        )
+    except subprocess.CalledProcessError as e:
+        sys.exit(f"[ERROR] Failed to run samtools view on {unique_bam} \n {e.output}")

meta_eukaryome_detect-0.1.0/meta_eukaryome_detect/meta_eukaryome_database.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+import gzip
+import hashlib
+import logging
+import os
+import shutil
+import sys
+
+import requests
+
+
+def md5sum_file(file):
+    """Computes MD5 sum of file.
+
+    Arguments:
+        file (str): Path of file to md5sum
+
+    Returns:
+        str: md5sum
+    """
+    block_size = 8192
+    m = hashlib.md5()
+    with open(file, "rb") as f:
+        while True:
+            data = f.read(block_size)
+            if not data:
+                return m.hexdigest()
+            m.update(data)
+
+
+def download_file(file_url, out_file):
+    """Download a file to disk
+
+    Streams a file from URL to disk.
+
+    Arguments:
+        file_url (str): URL of file to download
+        out_file (str): Target file path
+    """
+    with requests.get(file_url, stream=True) as r:
+        with open(out_file, "wb") as f:
+            shutil.copyfileobj(r.raw, f)
+
+
+def decompress_gzip_file(gz_file, out_file):
+    """Decompress a gzip file.
+
+    Uncompressed given gzip file to out_file.
+
+    Arguments:
+        gz_file (str): Path of gzip file
+        out_file (str): Path of target uncompressed out file
+    """
+    with gzip.open(gz_file, "rb") as f_in:
+        with open(out_file, "wb") as f_out:
+            shutil.copyfileobj(f_in, f_out)
+
+
+def get_md5_file(file_url):
+    """Read md5sums from url
+
+    Arguments:
+        file_url (str): URL of file
+
+    Returns:
+        dict: {file: md5sum}
+    """
+    md5s = requests.get(f"{file_url}").text.split("\n")
+    return {x.split('  ')[1]: x.split('  ')[0] for x in md5s if x}
+
+
+def check_md5(expected_md5, file_path):
+    """Check md5 and remove file if incorect.
+
+    Arguments:
+        expected_md5 (str): Expected md5 of file
+        file_path (str): Path of file
+    """
+    downloaded_md5 = md5sum_file(file_path)
+    if downloaded_md5 != expected_md5:
+        os.unlink(file_path)
+        return False
+    else:
+        return True
+
+
+def get_db(base_dir):
+    """Download GUNC DB.
+
+    Arguments:
+        base_dir (str): Path of output directory
+    """
+    logging.basicConfig(
+        format="%(asctime)s : %(message)s",
+        datefmt="%H:%M:%S",
+        level=logging.INFO,
+    )
+    logger = logging.getLogger(__name__)
+    if not os.path.isdir(base_dir):
+        sys.exit(f"[ERROR] Output Directory {base_dir} doesnt exist.")
+    base_url = "https://swifter.embl.de/~fullam/meta_eukaryome_database/"
+    files_to_download = get_md5_file(f"{base_url}MD5SUM_gzipped")
+    uncompressed_md5s = get_md5_file(f"{base_url}MD5SUM")
+    count_files_to_download = len(files_to_download)
+    logger.info("[INFO] DB downloading...")
+    for i, file_name in enumerate(files_to_download, 1):
+        logger.info(f"[INFO] Downloading {i}/{count_files_to_download} {file_name}")
+        gz_file_url = f"{base_url}{file_name}"
+        gz_file_path = os.path.join(base_dir, file_name)
+        out_file = gz_file_path.replace(".gz", "")
+        out_file_name = file_name.replace(".gz", "")
+
+        retry = 3
+        while retry:
+            download_file(gz_file_url, gz_file_path)
+            if not check_md5(files_to_download[file_name], gz_file_path):
+                logger.error(f"[ERROR] MD5 check failed, removing {gz_file_path}")
+                retry -= 1
+                continue
+            decompress_gzip_file(gz_file_path, out_file)
+            if not check_md5(uncompressed_md5s[out_file_name], out_file):
+                logger.error(f"[ERROR] MD5 check failed, removing {out_file}")
+                retry -= 1
+                continue
+            else:
+                break
+        else:
+            if retry == 0:
+                sys.exit('Downloading database files failed too many times')
+        os.unlink(gz_file_path)
+
+    logger.info("[INFO] DB download successful.")
+    logger.info(f"[INFO] DB path: {os.path.abspath(base_dir)}")

meta_eukaryome_detect-0.1.0/meta_eukaryome_detect/meta_eukaryome_detect.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+import argparse
+import logging
+import multiprocessing
+import os
+import shutil
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from . import create_ngless_template, depth_summary, external_tools, meta_eukaryome_database
+
+logger = logging.getLogger("meta_eukaryome_detect.py")
+
+
+def parse_args(args):
+    """Parse Arguments
+
+    Arguments:
+        args: List of args supplied to script.
+
+    Returns:
+        Namespace: assigned args
+
+    """
+    description = "Pathogen, Parasite, Eukaryote and Virus detection in metagenomes.\n"
+    formatter = lambda prog: argparse.HelpFormatter(prog, max_help_position=155)
+    parser = argparse.ArgumentParser(description=description, formatter_class=formatter)
+    subparsers = parser.add_subparsers(title="meta_eukaryome_detect subcommands", metavar="", dest="cmd")
+    run = subparsers.add_parser("run", help="Run Meta-Eukaryome-Detection.", formatter_class=formatter)
+    run_group = run.add_mutually_exclusive_group(required=True)
+    advanced_run = run.add_argument_group('Advanced Options')
+    download_db = subparsers.add_parser(
+        "download_db", help="Download meta_eukaryome_detect db.", formatter_class=formatter
+    )
+    run.add_argument(
+        "-d",
+        "--db_dir",
+        help="meta_eukaryome_database directory. Default: META_EUKARYOME_DETECT_DB_DIR envvar",
+        default=os.environ.get("META_EUKARYOME_DETECT_DB_DIR"),
+        metavar="",
+    )
+    run_group.add_argument(
+        "-i",
+        "--input_sample_dir",
+        help="""Input directory contining fasta files for a sample
+             (suffixes of the form _1.fq.gz .2.fq.gz single.fg.gz allowed)""",
+        metavar="",
+    )
+    run.add_argument(
+        "-s",
+        "--sample_name",
+        help="Name to give to output files, Default: Name of input dir",
+        default=None,
+        metavar="",
+    )
+    advanced_run.add_argument(
+        "--min_map_qual_plastid",
+        help="Minimum Mapping quality to use for plastid reference.",
+        default='1',
+        metavar="",
+    )
+    advanced_run.add_argument(
+        "--min_map_qual_mito",
+        help="Minimum Mapping quality to use for mitochondria reference.",
+        default='1',
+        metavar="",
+    )
+    advanced_run.add_argument(
+        "--min_map_qual_pr2",
+        help="Minimum Mapping quality to use for pr2 reference.",
+        default='20',
+        metavar="",
+    )
+    advanced_run.add_argument(
+        "--min_map_qual_virulence",
+        help="Minimum Mapping quality to use for virulence reference.",
+        default='20',
+        metavar="",
+    )
+    advanced_run.add_argument(
+        "--min_map_qual_virus",
+        help="Minimum Mapping quality to use for virus reference.",
+        default='0',
+        metavar="",
+    )
+    run.add_argument(
+        "-t",
+        "--threads",
+        help="number of CPU threads. Default: 4",
+        default="4",
+        metavar="",
+    )
+    run.add_argument(
+        "-p",
+        "--parallel",
+        help="Run all mappings in parallel (threads will be split between each of the 5 references)",
+        action="store_true",
+        default=False,
+    )
+    run.add_argument(
+        "-o",
+        "--out_dir",
+        help="Output dir.  Default: cwd",
+        default=os.getcwd(),
+        metavar="",
+    )
+    run.add_argument(
+        "--temp_dir",
+        help="Directory to store temp files. Default: cwd",
+        default=None,
+        metavar="",
+    )
+    run.add_argument(
+        "--keep_temp_files",
+        help="Do not remove temproary files",
+        action="store_true",
+        default=False,
+    )
+    run.add_argument(
+        "-v",
+        "--verbose",
+        help="Verbose output for debugging",
+        action="store_true",
+        default=False,
+    )
+    download_db.add_argument("path", help="Download database to given directory.", metavar="dest_path")
+    if not args:
+        parser.print_help(sys.stderr)
+        sys.exit(1)
+    download_db.add_argument(
+        "-v",
+        "--verbose",
+        help="Verbose output for debugging",
+        action="store_true",
+        default=False,
+    )
+    args = parser.parse_args(args)
+    return args
+
+
+def create_dir(path):
+    """Create a directory
+
+    Will create a directory if it doesnt already exist.
+
+    Arguments:
+        path (str): directory path
+    """
+    if not os.path.exists(path):
+        logger.debug(f'Creating dir: {path}')
+        os.makedirs(path)
+
+
+def start_checks(args):
+    """Checks if tool dependencies are available."""
+    if not external_tools.check_if_tool_exists("ngless"):
+        logger.error("Ngless not found.")
+        sys.exit(1)
+    if not external_tools.check_if_tool_exists("samtools"):
+        logger.error("Samtools not found.")
+        sys.exit(1)
+    if not os.path.isdir(args.out_dir):
+        logger.error(f"Output Directory {args.out_dir} doesnt exist.")
+        sys.exit(1)
+
+
+def run(args):
+    input_dir = Path(args.input_sample_dir)
+    if not args.sample_name:
+        sample_name = input_dir.name
+    else:
+        sample_name = args.sample_name
+
+    if args.temp_dir:
+        ngless_temp_dir = Path(args.temp_dir) / f'{sample_name}_ngless_temp_dir'
+    else:
+        ngless_temp_dir = Path(args.out_dir) / f'{sample_name}_ngless_temp_dir'
+
+    create_dir(ngless_temp_dir)
+    ngless_template_dir = ngless_temp_dir / 'ngless_templates'
+    create_dir(ngless_template_dir)
+    result_dir = Path(args.out_dir) / f'{sample_name}_metaeuk_output'
+    create_dir(result_dir)
+    templates = create_ngless_template.write_templates(ngless_template_dir, ngless_temp_dir, result_dir)
+    logger.info('Running Preprocessing of input files.')
+    logger.debug(f'Running template: {templates["preprocess"]}')
+    preprocessed_temp_dir = ngless_temp_dir / 'preprocessed'
+    create_dir(preprocessed_temp_dir)
+    external_tools.ngless(templates['preprocess'], args.threads, preprocessed_temp_dir, input_dir, args.verbose)
+    read_count_file = ngless_template_dir / 'preprocess.ngless.output_ngless' / 'fq.tsv'
+    shutil.copyfile(read_count_file, result_dir / 'readcounts.tsv')
+    mapping_qualities = {
+        'plastid': args.min_map_qual_plastid,
+        'mito': args.min_map_qual_mito,
+        'pr2': args.min_map_qual_pr2,
+        'virulence': args.min_map_qual_virulence,
+        'viruses': args.min_map_qual_virus,
+    }
+    meta = []
+    threads = int(args.threads)
+    if threads > 7 and args.parallel:
+        if threads < 21:
+            jobs = int(threads / 4)
+            threads = int(threads / jobs)
+        else:
+            jobs = 5
+            threads = int(threads / jobs)
+    else:
+        jobs = 1
+    for template in ['plastid', 'mito', 'pr2', 'virulence', 'viruses']:
+        meta.append(
+            (
+                template,
+                templates[template],
+                mapping_qualities[template],
+                args,
+                str(threads),
+                result_dir,
+                ngless_temp_dir,
+                sample_name,
+            )
+        )
+    p = multiprocessing.Pool(jobs)
+    p.map(run_detection, meta)
+    if not args.keep_temp_files:
+        shutil.rmtree(ngless_temp_dir)
+
+
+def run_detection(meta):
+    template, template_path, mapping_quality, args, threads, result_dir, ngless_temp_dir, sample_name = meta
+    logger.debug(f'Running reference: {template} with args: {meta}')
+    DB_path = Path(args.db_dir) / f'{template}_reference'
+    logger.debug(f'DB Path: {DB_path}')
+    external_tools.ngless(
+        template_path,
+        threads,
+        ngless_temp_dir,
+        ngless_temp_dir / 'preprocessed',
+        args.verbose,
+        DB_path,
+    )
+    unfiltered_bam = ngless_temp_dir / f"{template}_unfiltered.bam"
+    filtered_bam = result_dir / f"{template}_filtered.bam"
+    unique_bam = ngless_temp_dir / f"{template}_unique.bam"
+    unique_depth = ngless_temp_dir / f"{template}_unique.depth"
+    external_tools.samtools_unique(filtered_bam, unique_bam, mapping_quality, args.verbose)
+    external_tools.samtools_depth(unique_bam, unique_depth, args.verbose)
+    depth_summary.get_depth_summary(result_dir, template, unique_depth, Path(args.db_dir), sample_name)
+    if not args.keep_temp_files:
+        unfiltered_bam.unlink()
+        # filtered_bam.unlink()
+        unique_depth.unlink()
+    logger.info(f'Finished running reference: {template}')
+
+
+def main():
+    args = parse_args(sys.argv[1:])
+    if args.verbose:
+        logging.basicConfig(
+            format="%(asctime)s : [%(levelname)7s] : %(name)s:%(lineno)s %(funcName)20s() : %(message)s",
+            datefmt="%H:%M:%S",
+            level=logging.DEBUG,
+        )
+    else:
+        logging.basicConfig(
+            format="%(asctime)s : %(message)s",
+            datefmt="%H:%M:%S",
+            level=logging.INFO,
+        )
+    logger = logging.getLogger("meta_eukaryome_detect.py")
+    logger.debug(args)
+    start_time = datetime.now()
+    logger.info(f'START {start_time.strftime("%Y-%m-%d")}')
+    if args.cmd == "download_db":
+        meta_eukaryome_database.get_db(args.path)
+    if args.cmd == "run":
+        start_checks(args)
+        if not args.db_dir:
+            logger.error("Database_dir argument missing.")
+            sys.exit(1)
+        else:
+            if not os.path.isdir(args.db_dir):
+                logger.error("Database_dir not found.")
+                sys.exit(1)
+        run(args)
+    end_time = datetime.now()
+    logger.info(f'END {end_time.strftime("%Y-%m-%d")}')
+
+
+if __name__ == "__main__":
+    main()

meta_eukaryome_detect-0.1.0/pyproject.toml

@@ -0,0 +1,110 @@
+[tool]
+[tool.poetry]
+name = "meta_eukaryome_detect"
+version = "0.1.0"
+homepage = "https://git.embl.de/grp-bork/meta-eukaryome-detect"
+description = "Pathogen, Parasite, Eukaryote and Virus detection in metagenomes.."
+authors = ["Anthony Fullam <anthony.fullam@embl.de>"]
+readme = "README.md"
+license =  "MIT"
+classifiers=[
+    'Development Status :: 2 - Pre-Alpha',
+    'Intended Audience :: Developers',
+    'License :: OSI Approved :: MIT License',
+    'Natural Language :: English',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3.11',
+]
+packages = [
+    { include = "meta_eukaryome_detect" },
+    { include = "tests", format = "sdist" },
+]
+
+[tool.poetry.dependencies]
+python = ">=3.11,<4.0"
+black  = "^23.10.1"
+isort  = { version = "^5.8.0", optional = true}
+flake8  = { version = "^3.9.2", optional = true}
+flake8-docstrings = { version = "^1.6.0", optional = true }
+mypy = {version = "^0.900", optional = true}
+pytest  = { version = "^6.2.4", optional = true}
+pytest-cov  = { version = "^2.12.0", optional = true}
+tox  = { version = "^3.20.1", optional = true}
+virtualenv  = { version = "^20.2.2", optional = true}
+pip  = { version = "^20.3.1", optional = true}
+mkdocs  = "^1.5.3"
+mkdocs-include-markdown-plugin  = "^6.0.3"
+mkdocs-material  = { version = "^6.1.7", optional = true}
+mkdocstrings  = "^0.23.0"
+mkdocs-material-extensions  = { version = "^1.0.1", optional = true}
+twine  = { version = "^3.3.0", optional = true}
+mkdocs-autorefs = "^0.5.0"
+pre-commit = {version = "^2.12.0", optional = true}
+toml = {version = "^0.10.2", optional = true}
+bump2version = {version = "^1.0.1", optional = true}
+flask = "^3.0.0"
+jinja2 = "^3.1.2"
+mkdocstrings-python = "^1.7.3"
+requests = "^2.31.0"
+types-requests = "^2.31.0.10"
+pandas = "^2.2.3"
+
+[tool.poetry.extras]
+test = [
+    "pytest",
+    "black",
+    "isort",
+    "mypy",
+    "flake8",
+    "flake8-docstrings",
+    "pytest-cov"
+    ]
+
+dev = ["tox", "pre-commit", "virtualenv", "pip", "twine", "toml", "bump2version"]
+
+doc = [
+    "mkdocs",
+    "mkdocs-include-markdown-plugin",
+    "mkdocs-material",
+    "mkdocstrings",
+    "mkdocs-material-extension",
+    "mkdocs-autorefs"
+    ]
+
+[tool.poetry.scripts]
+meta-eukaryome-detect = 'meta_eukaryome_detect.meta_eukaryome_detect:main'
+
+[tool.black]
+line-length = 120
+skip-string-normalization = true
+target-version = ['py311']
+include = '\.pyi?$'
+exclude = '''
+/(
+    \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | _build
+  | buck-out
+  | build
+  | dist
+)/
+'''
+
+[tool.isort]
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+ensure_newline_before_comments = true
+line_length = 120
+skip_gitignore = true
+# you can skip files as below
+#skip_glob = docs/conf.py
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

meta_eukaryome_detect-0.1.0/tests/__init__.py

@@ -0,0 +1 @@
+"""Unit test package for meta-eukaryome-detect."""

meta_eukaryome_detect-0.1.0/tests/test_meta_eukaryome_detect.py

@@ -0,0 +1,2 @@
+#!/usr/bin/env python
+"""Tests for `meta_eukaryome_detect` package."""