krakenparser 0.6.0__py3-none-any.whl

krakenparser/__init__.py

@@ -0,0 +1,9 @@
+from .kpplot.stackedbar import stacked_barplot
+from .kpplot.streamgraph import streamgraph
+from .kpplot.clustermap import clustermap
+
+__all__ = [
+    "stacked_barplot",
+    "streamgraph",
+    "clustermap",
+]

krakenparser/alpha_div.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+
+import pandas as pd
+import numpy as np
+import sys
+import shutil
+import argparse
+from pathlib import Path
+
+
+# Define Shannon index
+def shannon_index(counts):
+    counts = np.array(counts)
+    counts = counts[counts > 0]
+    proportions = counts / counts.sum()
+    return -np.sum(proportions * np.log(proportions))
+
+
+# Define Pielou's evenness
+def pielou_evenness(counts):
+    counts = np.array(counts)
+    counts = counts[counts > 0]
+    H = shannon_index(counts)
+    S = len(counts)
+    return H / np.log(S) if S > 1 else 0
+
+
+# Define Chao1 richness estimator
+def chao1_index(counts):
+    counts = np.array(counts)
+    S_obs = np.sum(counts > 0)
+    F1 = np.sum(counts == 1)
+    F2 = np.sum(counts == 2)
+    if F2 == 0:
+        return S_obs + F1 * (F1 - 1) / 2
+    return S_obs + (F1 * F1) / (2 * F2)
+
+
+def calc_alpha_div(source_file, destination_file):
+    df = pd.read_csv(source_file, index_col=0)
+
+    results = []
+    for sample_id, row in df.iterrows():
+        counts = row.values
+        results.append(
+            {
+                "Sample": sample_id,
+                "Shannon": shannon_index(counts),
+                "Pielou": pielou_evenness(counts),
+                "Chao1": chao1_index(counts),
+            }
+        )
+
+    alpha_div_df = pd.DataFrame(results).set_index("Sample")
+    alpha_div_df.to_csv(destination_file)
+
+    # Get the path to the current directory (same location as the script)
+    current_dir = Path(__file__).resolve().parent
+    pycache_dir = current_dir / "__pycache__"
+
+    # Check if __pycache__ exists and remove it
+    if pycache_dir.exists() and pycache_dir.is_dir():
+        shutil.rmtree(pycache_dir)
+
+
+if __name__ == "__main__":
+    # Use argparse to parse command-line arguments
+    parser = argparse.ArgumentParser(description="Calculates α-diversity per sample.")
+    parser.add_argument(
+        "-i",
+        "--input",
+        required=True,
+        help="Path to the source file (total abundance on species level).",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        required=True,
+        help="Path to the destination file.",
+    )
+
+    args = parser.parse_args()
+
+    # Call the function with parsed arguments
+    calc_alpha_div(args.input, args.output)

krakenparser/beta_div.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+
+import pandas as pd
+import numpy as np
+import sys
+import shutil
+import argparse
+from pathlib import Path
+from skbio.diversity import beta_diversity
+from skbio.stats.subsample import subsample_counts
+
+
+def calc_beta_div(source_file, output_prefix, rarefaction_depth=1000):
+    df = pd.read_csv(source_file, index_col=0)
+
+    # Rarefy samples
+    rarefied_counts = []
+    sample_ids = []
+
+    for sample, row in df.iterrows():
+        counts = row.values.astype(int)
+        if counts.sum() >= rarefaction_depth:
+            rarefied = subsample_counts(counts, n=rarefaction_depth)
+            rarefied_counts.append(rarefied)
+            sample_ids.append(sample)
+
+    if len(rarefied_counts) < 2:
+        raise ValueError("Not enough samples passed the rarefaction threshold.")
+
+    # Compute Bray-Curtis and Jaccard
+    bray_dm = beta_diversity("braycurtis", rarefied_counts, ids=sample_ids)
+    jaccard_dm = beta_diversity("jaccard", rarefied_counts, ids=sample_ids)
+
+    # Save to CSV
+    bray_df = bray_dm.to_data_frame()
+    jaccard_df = jaccard_dm.to_data_frame()
+
+    bray_df.to_csv(f"{output_prefix}_braycurtis.csv")
+    jaccard_df.to_csv(f"{output_prefix}_jaccard.csv")
+
+    # Clean up __pycache__
+    current_dir = Path(__file__).resolve().parent
+    pycache_dir = current_dir / "__pycache__"
+    if pycache_dir.exists() and pycache_dir.is_dir():
+        shutil.rmtree(pycache_dir)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Calculate β-diversity (Bray-Curtis and Jaccard) with rarefaction."
+    )
+    parser.add_argument(
+        "-i", "--input", required=True, help="Input CSV count table (samples as rows)."
+    )
+    parser.add_argument(
+        "-o", "--output", required=True, help="Output prefix for distance matrices."
+    )
+    parser.add_argument(
+        "-d",
+        "--depth",
+        type=int,
+        default=1000,
+        help="Rarefaction depth (default: 1000).",
+    )
+    args = parser.parse_args()
+
+    calc_beta_div(args.input, args.output, args.depth)

krakenparser/combine_mpa.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+####################################################################
+#combine_mpa.py converts multiple outputs from kreport2mpa.py
+#Copyright (C) 2020 Jennifer Lu, jennifer.lu717@gmail.com
+
+#This file is part of KrakenTools.
+#KrakenTools is free software; you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation; either version 3 of the license, or
+#(at your option) any later version.
+
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of 
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+
+#You should have received a copy of the GNU General Public License
+#along with this program; if not, see <http://www.gnu.org/licenses/>.
+
+####################################################################
+#Jennifer Lu, jlu26@jhmi.edu
+#Updated: 07/12/2020
+#
+#This program reads multiple files in the 
+#an mpa-format (MetaPhlAn) style report (as output from kreport2mpa.py).
+#Each line represents a possible taxon classification. The first column is lists the 
+#domain, kingdom, phyla, etc, leading up to each taxon.
+#The levels are separated by the | delimiter, with the type of 
+#level specified before each name with a single letter and underscore
+#(d_ for domain, k_ for kingdom, etc). 
+#The second column is the number of reads classified within 
+#that taxon's subtree.
+#
+#Input files:
+#   - MetaPhlAn format (mpa-format) files with two columns 
+#   - All files must be generated from the same database, with the same
+#     options from kreport2krona.py or errors may occur
+#     
+#Input Parameters to Specify [OPTIONAL]:
+#   - header_line = prints a header line in mpa-report 
+#       [Default: no header]
+#   - intermediate-ranks = includes non-traditional taxon levels
+#       (traditional levels: domain, kingdom, phylum, class, order, 
+#       family, genus, species)
+#       [Default: no intermediate ranks]
+#Output file format (tab-delimited)
+#   - Taxonomy tree levels |-delimited, with level type [d,k,p,c,o,f,g,s,x]
+#   - Number of reads within subtree of the specified level
+#
+#Methods
+#   - main
+#
+import os, sys, argparse
+
+#Main method
+def main():
+    #Parse arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-i', '--input', required=True,
+        nargs='+', dest='in_files',
+        help='Input files for this program (files generated by kreport2mpa.py)')
+    parser.add_argument('-o', '--output', required=True,
+        dest='o_file', help='Single mpa-report file name')
+    args=parser.parse_args()
+
+    #Process each file 
+    samples = {} #Map number to name
+    sample_count = 0 
+    values = {} #Map taxon tree to sample to number 
+    parent2child = {}
+    toparse = []
+    sys.stdout.write(" Number of files to parse: %i\n" % len(args.in_files))
+    for in_file in args.in_files:
+        i_file = open(in_file,'r')
+        sample_count += 1
+        sample_name = "Sample #" + str(sample_count) 
+        for line in i_file:
+            #Check for header line 
+            if line[0] == "#":
+                sample_name = line.strip().split('\t')[-1]
+                continue 
+            #Otherwise
+            [classification, val] = line.strip().split('\t')
+            #Check for parents
+            split_vals = classification.split("|")
+            curr_parent = ''
+            for i in range(0,len(split_vals)):
+                test_val = "|".join(split_vals[0:i]) 
+                if test_val in values: 
+                    curr_parent = test_val 
+            #No parent
+            if curr_parent == '':
+                if classification not in values:
+                    toparse.append(classification) 
+            #Most specific parent found 
+            if curr_parent != '':
+                if curr_parent not in parent2child:
+                    parent2child[curr_parent] = []
+                if classification not in parent2child[curr_parent]:
+                    parent2child[curr_parent].append(classification)
+            #Save classification to value map
+            if classification not in values:
+                values[classification] = {}
+            values[classification][sample_count] = val
+        #Save sample name 
+        samples[sample_count] = sample_name 
+    
+    sys.stdout.write(" Number of classifications to write: %i\n" % len(values))
+    sys.stdout.write("\t%i classifications printed" % 0)
+    #Write header
+    o_file = open(args.o_file, 'w')
+    o_file.write("#Classification") 
+    for i in range(1, sample_count+1):
+        o_file.write("\t" + samples[i])
+    o_file.write("\n") 
+    
+    #Write each line  
+    parsed = {} 
+    count_c = 0 
+    while len(toparse) > 0:
+        curr_c = toparse.pop(0)
+        #Add all children to stack 
+        if curr_c in parent2child: 
+            for child in parent2child[curr_c]: 
+                toparse.insert(0, child) 
+        #For the current classification, print per sample
+        o_file.write(curr_c) 
+        for i in range(1,sample_count + 1):
+            if i in values[curr_c]:
+                o_file.write("\t" + values[curr_c][i])
+            else:
+                o_file.write("\t0")
+        o_file.write("\n")
+        count_c += 1
+        sys.stdout.write("\r\t%i classifications printed" % count_c)
+        sys.stdout.flush()
+    o_file.close() 
+    sys.stdout.write("\r\t%i classifications printed\n" % count_c)
+    sys.stdout.flush()
+
+if __name__ == "__main__":
+    main()

krakenparser/convert2csv.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+import shutil
+from pathlib import Path
+import argparse
+import pandas as pd
+
+
+def convert_to_csv(input_file, output_file):
+    # Read the entire file into a DataFrame
+    data = pd.read_csv(input_file, sep="\t", header=None)
+
+    # Set the first row as the header
+    data.columns = data.iloc[0]
+    data = data.drop(data.index[0])
+
+    # Transpose the DataFrame so that sample names become rows and microbial taxa with their abundance become columns
+    data_transposed = data.T
+    data_transposed.columns = data_transposed.iloc[0]
+    data_transposed = data_transposed.drop(data_transposed.index[0])
+
+    # Save the transposed data to a new CSV file
+    data_transposed.to_csv(output_file, index_label="Sample_id")
+    print(f"Data has been successfully converted and saved as '{output_file}'.")
+
+    # Remove pycache if it exists
+    current_dir = Path(__file__).resolve().parent
+    pycache_dir = current_dir / "__pycache__"
+    if pycache_dir.exists() and pycache_dir.is_dir():
+        shutil.rmtree(pycache_dir)
+
+
+if __name__ == "__main__":
+    # Use argparse to handle command-line arguments
+    parser = argparse.ArgumentParser(
+        description="Reads a TXT file, reorganizes the data, and converts it into a CSV file."
+    )
+    parser.add_argument(
+        "-i",
+        "--input",
+        required=True,
+        help="Path to the input TXT file. This file should contain sample names in columns and microbial taxa in rows.",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        required=True,
+        help="Path to the output CSV file. The script will restructure the data and save it here.",
+    )
+
+    args = parser.parse_args()
+
+    # Call function with parsed arguments
+    convert_to_csv(args.input, args.output)

krakenparser/decombine.sh

@@ -0,0 +1,123 @@
+#!/bin/bash
+
+# Function to display detailed usage information
+usage() {
+    echo "Usage: $(basename "$0") -i PATH_TO_SOURCE_FILE -o PATH_TO_DESTINATION"
+    echo
+    echo "  -i, --input    PATH_TO_SOURCE_FILE    Path to the Combined MPA input file to be processed."
+    echo "  -o, --output   PATH_TO_DESTINATION    Path to the directory where processed output files will be stored."
+    echo "  -h, --help                           Display this help message and exit."
+    echo
+    echo "Description:"
+    echo "  This script processes a combined mpa file by extracting different taxonomic levels"
+    echo "  (species, genus, family, order, class, and phylum) and saving the results as separate text files."
+    echo "  Additionally, it removes human-related sequences to improve data accuracy."
+    echo
+    echo "Processing Details:"
+    echo "  - Extracts taxonomic levels using 'grep' with specific patterns."
+    echo "  - Filters out undesired taxonomic entries such as:"
+    echo "    - Species: Homo sapiens"
+    echo "    - Genus: Homo"
+    echo "    - Family: Hominidae"
+    echo "    - Order: Primates"
+    echo "    - Class: Mammalia"
+    echo "    - Phylum: Chordata"
+    echo "  - Outputs are stored as text files inside the specified destination directory."
+    exit 0
+}
+
+# Initialize variables
+SOURCE_FILE=""
+DESTINATION_DIR=""
+
+# Parse command-line arguments
+while [[ "$#" -gt 0 ]]; do
+    case "$1" in
+        -i|--input) SOURCE_FILE="$2"; shift 2 ;;
+        -o|--output) DESTINATION_DIR="$2"; shift 2 ;;
+        -h|--help) usage ;;
+        *) echo "Error: Unknown option $1"; usage ;;
+    esac
+done
+
+# Check if required arguments are provided
+if [[ -z "$SOURCE_FILE" || -z "$DESTINATION_DIR" ]]; then
+    echo "Error: Both input (-i) and output (-o) paths are required."
+    usage
+fi
+
+# Check if source file exists
+if [[ ! -f "$SOURCE_FILE" ]]; then
+    echo "Error: Input file '$SOURCE_FILE' not found!"
+    exit 1
+fi
+
+# Create destination directories
+mkdir -p "${DESTINATION_DIR}/txt"
+mkdir -p "${DESTINATION_DIR}/csv"
+
+# Process input file and generate output files
+grep -E "s__" "${SOURCE_FILE}" \
+| grep -v "t__" \
+| grep -v "s__Homo_sapiens" \
+| sed "s/^.*|//g" \
+| sed "s/SRS[0-9]*-//g" \
+> "${DESTINATION_DIR}/txt/counts_species.txt"
+
+grep -E "g__" "${SOURCE_FILE}" \
+| grep -v "t__" \
+| grep -v "s__" \
+| grep -v "g__Homo" \
+| sed "s/^.*|//g" \
+| sed "s/SRS[0-9]*-//g" \
+> "${DESTINATION_DIR}/txt/counts_genus.txt"
+
+grep -E "f__" "${SOURCE_FILE}" \
+| grep -v "t__" \
+| grep -v "s__" \
+| grep -v "g__" \
+| grep -v "f__Hominidae" \
+| sed "s/^.*|//g" \
+| sed "s/SRS[0-9]*-//g" \
+> "${DESTINATION_DIR}/txt/counts_family.txt"
+
+grep -E "o__" "${SOURCE_FILE}" \
+| grep -v "t__" \
+| grep -v "s__" \
+| grep -v "g__" \
+| grep -v "f__" \
+| grep -v "o__Primates" \
+| sed "s/^.*|//g" \
+| sed "s/SRS[0-9]*-//g" \
+> "${DESTINATION_DIR}/txt/counts_order.txt"
+
+grep -E "c__" "${SOURCE_FILE}" \
+| grep -v "t__" \
+| grep -v "s__" \
+| grep -v "g__" \
+| grep -v "f__" \
+| grep -v "o__" \
+| grep -v "c__Mammalia" \
+| sed "s/^.*|//g" \
+| sed "s/SRS[0-9]*-//g" \
+> "${DESTINATION_DIR}/txt/counts_class.txt"
+
+grep -E "p__" "${SOURCE_FILE}" \
+| grep -v "t__" \
+| grep -v "s__" \
+| grep -v "g__" \
+| grep -v "f__" \
+| grep -v "o__" \
+| grep -v "c__" \
+| grep -v "p__Chordata" \
+| sed "s/^.*|//g" \
+| sed "s/SRS[0-9]*-//g" \
+> "${DESTINATION_DIR}/txt/counts_phylum.txt"
+
+# Check for errors
+if [ $? -ne 0 ]; then
+    echo "Error: Failed to run decombine.sh"
+    exit 1
+fi
+
+echo "MPA file decombined successfully. Output stored in $DESTINATION_DIR"

krakenparser/decombine_viruses.sh

@@ -0,0 +1,111 @@
+#!/bin/bash
+
+# Function to display detailed usage information
+usage() {
+    echo "Usage: $(basename "$0") -i PATH_TO_SOURCE_FILE -o PATH_TO_DESTINATION"
+    echo
+    echo "  -i, --input    PATH_TO_SOURCE_FILE    Path to the Combined MPA input file to be processed."
+    echo "  -o, --output   PATH_TO_DESTINATION    Path to the directory where processed output files will be stored."
+    echo "  -h, --help                           Display this help message and exit."
+    echo
+    echo "Description:"
+    echo "  This script processes a combined mpa file by extracting different taxonomic levels using only VIRUSES domain"
+    echo "  (species, genus, family, order, class, and phylum) and saving the results as separate text files."
+    echo
+    echo "Processing Details:"
+    echo "  - Extracts taxonomic levels only on VIRUSES domain using 'grep' with specific patterns."
+    echo "  - Outputs are stored as text files inside the specified destination directory."
+    exit 0
+}
+
+# Initialize variables
+SOURCE_FILE=""
+DESTINATION_DIR=""
+
+# Parse command-line arguments
+while [[ "$#" -gt 0 ]]; do
+    case "$1" in
+        -i|--input) SOURCE_FILE="$2"; shift 2 ;;
+        -o|--output) DESTINATION_DIR="$2"; shift 2 ;;
+        -h|--help) usage ;;
+        *) echo "Error: Unknown option $1"; usage ;;
+    esac
+done
+
+# Check if required arguments are provided
+if [[ -z "$SOURCE_FILE" || -z "$DESTINATION_DIR" ]]; then
+    echo "Error: Both input (-i) and output (-o) paths are required."
+    usage
+fi
+
+# Check if source file exists
+if [[ ! -f "$SOURCE_FILE" ]]; then
+    echo "Error: Input file '$SOURCE_FILE' not found!"
+    exit 1
+fi
+
+# Create destination directories
+mkdir -p "${DESTINATION_DIR}/txt"
+mkdir -p "${DESTINATION_DIR}/csv"
+
+VIRUSES_BUFFER=$(grep -E "d__Viruses" "${SOURCE_FILE}")
+
+# Process input file and generate output files
+echo "$VIRUSES_BUFFER" | grep -E "s__" \
+    | grep -v "t__" \
+    | sed "s/^.*|//g" \
+    | sed "s/SRS[0-9]*-//g" \
+    > "${DESTINATION_DIR}/txt/counts_species.txt"
+
+echo "$VIRUSES_BUFFER" | grep -E "g__" \
+    | grep -v "t__" \
+    | grep -v "s__" \
+    | sed "s/^.*|//g" \
+    | sed "s/SRS[0-9]*-//g" \
+    > "${DESTINATION_DIR}/txt/counts_genus.txt"
+
+echo "$VIRUSES_BUFFER" | grep -E "f__" \
+    | grep -v "t__" \
+    | grep -v "s__" \
+    | grep -v "g__" \
+    | sed "s/^.*|//g" \
+    | sed "s/SRS[0-9]*-//g" \
+    > "${DESTINATION_DIR}/txt/counts_family.txt"
+
+echo "$VIRUSES_BUFFER" | grep -E "o__" \
+    | grep -v "t__" \
+    | grep -v "s__" \
+    | grep -v "g__" \
+    | grep -v "f__" \
+    | sed "s/^.*|//g" \
+    | sed "s/SRS[0-9]*-//g" \
+    > "${DESTINATION_DIR}/txt/counts_order.txt"
+
+echo "$VIRUSES_BUFFER" | grep -E "c__" \
+    | grep -v "t__" \
+    | grep -v "s__" \
+    | grep -v "g__" \
+    | grep -v "f__" \
+    | grep -v "o__" \
+    | sed "s/^.*|//g" \
+    | sed "s/SRS[0-9]*-//g" \
+    > "${DESTINATION_DIR}/txt/counts_class.txt"
+
+echo "$VIRUSES_BUFFER" | grep -E "p__" \
+    | grep -v "t__" \
+    | grep -v "s__" \
+    | grep -v "g__" \
+    | grep -v "f__" \
+    | grep -v "o__" \
+    | grep -v "c__" \
+    | sed "s/^.*|//g" \
+    | sed "s/SRS[0-9]*-//g" \
+    > "${DESTINATION_DIR}/txt/counts_phylum.txt"
+
+# Check for errors
+if [ $? -ne 0 ]; then
+    echo "Error: Failed to run decombine_viruses.sh"
+    exit 1
+fi
+
+echo "MPA file decombined successfully. Output stored in $DESTINATION_DIR"