rhinotype 1.0.0__tar.gz

rhinotype-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 omicscodeathon
+
+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.

rhinotype-1.0.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: rhinotype
+Version: 1.0.0
+Summary: A python tool used to automatically genotype rhinovirus.
+Author-email: Ephantus Wambui <ephywambui72@gmail.com>, Daniel Okoro <ugookorodaniel620@gmail.com>, Andrew Acheampong <acheampongandrews1999@gmail.com>, Parcelli Jepchirchir <parcelmaiyo@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/omicscodeathon/rhinotype
+Keywords: bioinformatics,virology,genotyping,rhinovirus,genotype
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: numpy>=2.3
+Requires-Dist: pandas>=2.3
+Requires-Dist: seaborn>=0.13
+Requires-Dist: scipy>=1.16
+Requires-Dist: biopython>=1.86
+Dynamic: license-file
+
+# rhinotype
+rhinotype: A Python Package for the Classification of Rhinoviruses
+
+## Table of contents
+
+1. [Background](#background)
+2. [Workflow](#workflow)
+3. [Installation](#installation)
+4. [getprototypeseqs](#getprototypeseqs)
+5. [readfasta](#readfasta)
+6. [SNPeek](#snpeek)
+7. [assign_types](#assign_types)
+8. [pairwise_distances](#pairwise_distances)
+9. [overall_mean_distance](#overall_mean_distance)
+10. [count_SNPs](#count_snps)
+11. [plot_frequency](#plot_frequency)
+12. [plot_distances](#plot_distances)
+13. [plot_tree](#plot_tree)
+14. [plot_AA](#plot_aa)
+15. [Citation](#citation)
+16. [Contributors](#contributors)
+
+## <a id="background"></a>Background 
+
+Among the major causes of human respiratory infections, rhinovirus causes around 50% of all the year-round cases of common cold. This virus belongs to the Enterovirus genus in the Picornaviridae family. RV-A, RV-B, and RV-C are the three species under the genus Rhinovirus, each having about 169 different genotypes. Rhinoviruses are positive-sense, non-enveloped RNA viruses with approximately 7.2 kilobases long genome. The genome codes for seven non-structural proteins and four structural proteins—VP1, VP2, VP3, and VP4—which are part of the genome encoding viral replication and host infection mechanisms. Genotyping of Rhinovirus, until now, is done manually, while an R software package, [rhinotypeR](https://github.com/omicscodeathon/rhinotypeR/tree/main), allows for fully automated genotyping based on the VP4 region. The Python rhinovirus type package brings out VP1 and VP4 regions that aim to improve acuity in genotyping. The VP1 region has been tested to display better acuity in genotypic identification, while the VP4/2 region ensures compatibility under one universal amplification protocol for rapid genotyping.
+
+## <a id="workflow"></a>Workflow
+
+![Workflow](figures/rhinotype%20workflow.svg)
+
+## <a id="installation"></a>Installation
+
+You can install the package using the following command:
+
+```
+pip install rhinotype
+```
+
+**Note:** This package requires [MAFFT](https://mafft.cbrc.jp/alignment/software/) for sequence alignment. Please ensure that you have MAFFT installed and that it is available in your system's PATH.
+
+#### Run the package
+
+```
+rhinotype --mode {demo,user} --region {Vp1,Vp4/2} --threshold {VALUE} [--input FILE] [--model MODEL] --threads {VALUE}
+```
+
+## <a id="getprototypeseqs"></a>getprotypeseqs
+
+Gets the prototype sequences of the Rhinovirus genotypes and save the reference fasta file into RVRefs directory. Making both VP1 and VP4/2 sequences available depending on whch region you have. The tool then combines user sequences together with the prototype sequences and align them using MAFFT or any other alignment tool.
+
+## <a id="readfasta"></a>readfasta
+
+Reads the alignments/sequences. Compares the input sequences and pads the short sequences with - until they are long as the longest sequence. The sequences are then stored in a dictionary with the sequence name as the key and the sequence as the value.
+
+## <a id="snpeek"></a>SNPeek
+
+SNPeek function visualizes single nuclotide polymorphisms(SNPs) using the users sequences, relative to a specified reference sequence. To specify a reference sequence, the user should move the sequence to the bottom of the alignment. Substitutions are color coded by nucleotide: A = green, T = red, C = blue, G = yellow.
+
+## <a id="assign_types"></a>assign_types
+
+The ```assign_types``` function assigns genotype to the sequences in the fasta file by comparing them to the prototype sequences. The classification is based on pairwise distances calculated using a specified distance model. Users can adjust parameters for gap deletion and threshold to control the classification process. The function reads prototype sequences from predefined CSV files based on the specified prototype type.
+
+Parameters:
+
+- ```fasta_data``` (DataFrame): A DataFrame containing the sequences to be classified.
+- ```model``` (str): The distance model to use (default is 'p-distance').
+- ```gap_deletion``` (bool): Whether to apply gap deletion in distance calculations (default is True).
+- ```threshold``` (float): The distance threshold for classification (default is 0.105)
+
+## <a id="pairwise_distances"></a>pairwise_distances
+
+Calculates pairwise genetic distances between sequences in a FASTA dataset using the specified distance model. The function supports various models for distance calculation and can optionally apply gap deletion. The result is a DataFrame showing the distances between each pair of sequences.
+
+Parameters:
+
+- ```fasta_data``` (DataFrame): A DataFrame containing the sequences to be analyzed.
+- ```model``` (str): The distance model to use. Options include:
+    - ```"p-distance"```: Simple proportion of differing sites.
+    - ```"JC"```: Jukes-Cantor model.
+    - ```"Kimura2p"```: Kimura 2-parameter model.
+    - ```"Tamura3p"```: Tamura 3-parameter model.
+- ```gap_deletion``` (bool): Whether to apply gap deletion in the distance calculation (default is True).
+- ```Output```: The function returns a numpy array containing the pairwise distances between the sequences
+
+## <a id="overall_mean_distance"></a>overall_mean_distance
+
+Calculates the overall mean genetic distance between sequences using various distance models. The function supports multiple models and can optionally handle gap deletion in sequences. It provides an average distance value based on the chosen model.
+
+## <a id="count_snps"></a>count_SNPs
+
+Counts the single nucleotide polymorphisms (SNPs) in the provided sequence data and can optionally handle gap deletion in the sequences.
+
+## <a id="plot_frequency"></a>plot_frequency
+
+Generates a bar chart visualizing the frequency of assigned types from a DataFrame. The function creates a bar chart where each bar represents the count of a specific type, and colors are used to differentiate between species. The chart is saved as an image file and can optionally include a legend.
+
+## <a id="plot_distances"></a>plot_distances
+
+Generates a heatmap to visualize the pairwise genetic distances between sequences and saves the plot as an image file. The color scale represents the magnitude of genetic distances.
+
+## <a id="plot_tree"></a>plot_tree
+
+Generates a hierarchical clustering dendrogram from the pairwise genetic distances between sequences. The function performs complete linkage clustering and visualizes the results as a tree diagram. The dendrogram is saved as an image file.
+
+## <a id="plot_aa"></a>plot_AA
+
+Visualizes amino acid differences between protein sequences. The function compares each sequence to a reference sequence and plots the differences as colored bars, categorizing amino acids based on their properties. The plot is saved as an image file.
+
+## <a id="citation"></a>Citation
+
+## <a id="contributors"></a>Contributors
+
+1. [Ephantus Wambui](https://github.com/Ephantus-Wambui)
+
+2. [Daniel Okoro](https://github.com/danny6200)
+
+3. [Andrew Acheampong](https://github.com/AcheampongAndy)
+
+4. [Parcelli Jepchirchir](https://github.com/Parcelli)

rhinotype-1.0.0/README.md

@@ -0,0 +1,119 @@
+# rhinotype
+rhinotype: A Python Package for the Classification of Rhinoviruses
+
+## Table of contents
+
+1. [Background](#background)
+2. [Workflow](#workflow)
+3. [Installation](#installation)
+4. [getprototypeseqs](#getprototypeseqs)
+5. [readfasta](#readfasta)
+6. [SNPeek](#snpeek)
+7. [assign_types](#assign_types)
+8. [pairwise_distances](#pairwise_distances)
+9. [overall_mean_distance](#overall_mean_distance)
+10. [count_SNPs](#count_snps)
+11. [plot_frequency](#plot_frequency)
+12. [plot_distances](#plot_distances)
+13. [plot_tree](#plot_tree)
+14. [plot_AA](#plot_aa)
+15. [Citation](#citation)
+16. [Contributors](#contributors)
+
+## <a id="background"></a>Background 
+
+Among the major causes of human respiratory infections, rhinovirus causes around 50% of all the year-round cases of common cold. This virus belongs to the Enterovirus genus in the Picornaviridae family. RV-A, RV-B, and RV-C are the three species under the genus Rhinovirus, each having about 169 different genotypes. Rhinoviruses are positive-sense, non-enveloped RNA viruses with approximately 7.2 kilobases long genome. The genome codes for seven non-structural proteins and four structural proteins—VP1, VP2, VP3, and VP4—which are part of the genome encoding viral replication and host infection mechanisms. Genotyping of Rhinovirus, until now, is done manually, while an R software package, [rhinotypeR](https://github.com/omicscodeathon/rhinotypeR/tree/main), allows for fully automated genotyping based on the VP4 region. The Python rhinovirus type package brings out VP1 and VP4 regions that aim to improve acuity in genotyping. The VP1 region has been tested to display better acuity in genotypic identification, while the VP4/2 region ensures compatibility under one universal amplification protocol for rapid genotyping.
+
+## <a id="workflow"></a>Workflow
+
+![Workflow](figures/rhinotype%20workflow.svg)
+
+## <a id="installation"></a>Installation
+
+You can install the package using the following command:
+
+```
+pip install rhinotype
+```
+
+**Note:** This package requires [MAFFT](https://mafft.cbrc.jp/alignment/software/) for sequence alignment. Please ensure that you have MAFFT installed and that it is available in your system's PATH.
+
+#### Run the package
+
+```
+rhinotype --mode {demo,user} --region {Vp1,Vp4/2} --threshold {VALUE} [--input FILE] [--model MODEL] --threads {VALUE}
+```
+
+## <a id="getprototypeseqs"></a>getprotypeseqs
+
+Gets the prototype sequences of the Rhinovirus genotypes and save the reference fasta file into RVRefs directory. Making both VP1 and VP4/2 sequences available depending on whch region you have. The tool then combines user sequences together with the prototype sequences and align them using MAFFT or any other alignment tool.
+
+## <a id="readfasta"></a>readfasta
+
+Reads the alignments/sequences. Compares the input sequences and pads the short sequences with - until they are long as the longest sequence. The sequences are then stored in a dictionary with the sequence name as the key and the sequence as the value.
+
+## <a id="snpeek"></a>SNPeek
+
+SNPeek function visualizes single nuclotide polymorphisms(SNPs) using the users sequences, relative to a specified reference sequence. To specify a reference sequence, the user should move the sequence to the bottom of the alignment. Substitutions are color coded by nucleotide: A = green, T = red, C = blue, G = yellow.
+
+## <a id="assign_types"></a>assign_types
+
+The ```assign_types``` function assigns genotype to the sequences in the fasta file by comparing them to the prototype sequences. The classification is based on pairwise distances calculated using a specified distance model. Users can adjust parameters for gap deletion and threshold to control the classification process. The function reads prototype sequences from predefined CSV files based on the specified prototype type.
+
+Parameters:
+
+- ```fasta_data``` (DataFrame): A DataFrame containing the sequences to be classified.
+- ```model``` (str): The distance model to use (default is 'p-distance').
+- ```gap_deletion``` (bool): Whether to apply gap deletion in distance calculations (default is True).
+- ```threshold``` (float): The distance threshold for classification (default is 0.105)
+
+## <a id="pairwise_distances"></a>pairwise_distances
+
+Calculates pairwise genetic distances between sequences in a FASTA dataset using the specified distance model. The function supports various models for distance calculation and can optionally apply gap deletion. The result is a DataFrame showing the distances between each pair of sequences.
+
+Parameters:
+
+- ```fasta_data``` (DataFrame): A DataFrame containing the sequences to be analyzed.
+- ```model``` (str): The distance model to use. Options include:
+    - ```"p-distance"```: Simple proportion of differing sites.
+    - ```"JC"```: Jukes-Cantor model.
+    - ```"Kimura2p"```: Kimura 2-parameter model.
+    - ```"Tamura3p"```: Tamura 3-parameter model.
+- ```gap_deletion``` (bool): Whether to apply gap deletion in the distance calculation (default is True).
+- ```Output```: The function returns a numpy array containing the pairwise distances between the sequences
+
+## <a id="overall_mean_distance"></a>overall_mean_distance
+
+Calculates the overall mean genetic distance between sequences using various distance models. The function supports multiple models and can optionally handle gap deletion in sequences. It provides an average distance value based on the chosen model.
+
+## <a id="count_snps"></a>count_SNPs
+
+Counts the single nucleotide polymorphisms (SNPs) in the provided sequence data and can optionally handle gap deletion in the sequences.
+
+## <a id="plot_frequency"></a>plot_frequency
+
+Generates a bar chart visualizing the frequency of assigned types from a DataFrame. The function creates a bar chart where each bar represents the count of a specific type, and colors are used to differentiate between species. The chart is saved as an image file and can optionally include a legend.
+
+## <a id="plot_distances"></a>plot_distances
+
+Generates a heatmap to visualize the pairwise genetic distances between sequences and saves the plot as an image file. The color scale represents the magnitude of genetic distances.
+
+## <a id="plot_tree"></a>plot_tree
+
+Generates a hierarchical clustering dendrogram from the pairwise genetic distances between sequences. The function performs complete linkage clustering and visualizes the results as a tree diagram. The dendrogram is saved as an image file.
+
+## <a id="plot_aa"></a>plot_AA
+
+Visualizes amino acid differences between protein sequences. The function compares each sequence to a reference sequence and plots the differences as colored bars, categorizing amino acids based on their properties. The plot is saved as an image file.
+
+## <a id="citation"></a>Citation
+
+## <a id="contributors"></a>Contributors
+
+1. [Ephantus Wambui](https://github.com/Ephantus-Wambui)
+
+2. [Daniel Okoro](https://github.com/danny6200)
+
+3. [Andrew Acheampong](https://github.com/AcheampongAndy)
+
+4. [Parcelli Jepchirchir](https://github.com/Parcelli)

rhinotype-1.0.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rhinotype"
+version = "1.0.0"
+description = "A python tool used to automatically genotype rhinovirus."
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+    {name = "Ephantus Wambui", email = "ephywambui72@gmail.com"},
+    {name = "Daniel Okoro", email = "ugookorodaniel620@gmail.com"},
+    {name = "Andrew Acheampong", email = "acheampongandrews1999@gmail.com"},
+    {name = "Parcelli Jepchirchir", email  = "parcelmaiyo@gmail.com"}
+]
+license = {text = "MIT"}
+keywords = ["bioinformatics", "virology", "genotyping", "rhinovirus", "genotype"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+]
+
+dependencies = [
+    "matplotlib >= 3.8",
+    "numpy >= 2.3",
+    "pandas >= 2.3",
+    "seaborn >= 0.13",
+    "scipy >= 1.16",
+    "biopython >= 1.86"
+]
+
+[project.urls]
+Homepage = "https://github.com/omicscodeathon/rhinotype"
+
+[project.scripts]
+rhinotype = "rhinotype.main:main"
+
+[tool.setuptools.package-data]
+rhinotype = ["data/*.fasta", "data/*.csv"]

rhinotype-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rhinotype-1.0.0/src/rhinotype/SNPeek.py

@@ -0,0 +1,65 @@
+import os
+import pandas as pd
+from Bio import SeqIO
+import matplotlib.pyplot as plt
+import numpy as np
+
+# --- FASTA Reading Function ---
+def read_fasta(fasta_file):
+    sequences = []
+    headers = []
+    for record in SeqIO.parse(fasta_file, "fasta"):
+        sequences.append(str(record.seq))
+        headers.append(record.id)
+    return {"sequences": sequences, "headers": headers}
+
+# --- Sequence Comparison Function ---
+def compare_sequences(seqA, seqB):
+    differences = [i for i in range(len(seqA)) if seqA[i] != seqB[i]]
+    subsType = [seqB[i] for i in differences]
+    return pd.DataFrame({"position": differences, "subsType": subsType})
+
+# --- SNPeek Plotting Function ---
+def SNPeek(fastaData, region="Unknown", output_dir=None, showLegend=False):
+    sequences = fastaData["sequences"]
+    seqNames = fastaData["headers"]
+    genomeLength = max([len(seq) for seq in sequences])
+
+    # Define color map for nucleotide substitutions
+    colorMap = {"A": "green", "T": "red", "C": "blue", "G": "yellow"}
+
+    diffList = []
+    for i in range(1, len(sequences)):
+        diff = compare_sequences(sequences[0], sequences[i])
+        diff["color"] = diff["subsType"].map(colorMap).fillna("black")
+        diffList.append(diff)
+
+    plt.figure(figsize=(15, 10))
+    plt.xlim(1, genomeLength)
+    plt.ylim(0.5, len(sequences))
+    plt.xlabel(f"Genome Position (reference: {seqNames[-1]})", fontsize=10)
+    plt.yticks(ticks=np.arange(1, len(sequences) + 1), labels=seqNames, fontsize=10)
+    plt.gca().yaxis.set_tick_params(labelsize=8)
+    plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.1)
+
+    for i, diff in enumerate(diffList, start=1):
+        for _, row in diff.iterrows():
+            plt.plot([row["position"], row["position"]], [i - 0.25, i + 0.25], color=row["color"], marker="|")
+
+    if showLegend:
+        plt.legend(["A", "T", "C", "G", "Other"],
+                   handlelength=0.8, markerfirst=False,
+                   loc="upper left", bbox_to_anchor=(1, 1),
+                   facecolor="white", framealpha=0.7)
+
+    plt.title(f"{region} Nucleotide Differences from Reference Sequence")
+
+    if output_dir is None:
+        output_dir = os.path.join(os.getcwd(), "figures")
+
+    os.makedirs(output_dir, exist_ok=True)
+    save_path = os.path.join(output_dir, "SNPeek.png")
+    plt.savefig(save_path)
+    # plt.show()
+
+    print(f"Figure saved at: {save_path}")

rhinotype-1.0.0/src/rhinotype/__init__.py

@@ -0,0 +1,21 @@
+from importlib import metadata as _metadata
+
+"""
+rhinotype package top-level.
+
+Provides a robust way to expose the package version without importing
+submodules at package import time.
+"""
+
+def _get_version():
+    try:
+        return _metadata.version("rhinotype")
+    except Exception:
+        # Fall back to a safe default if package metadata isn't available
+        return "0.0.0"
+
+__all__ = ["__version__"]
+__version__ = _get_version()
+
+# Clean up names from the package namespace
+del _get_version, _metadata

rhinotype-1.0.0/src/rhinotype/assign_types.py

@@ -0,0 +1,150 @@
+import os
+import pandas as pd
+import numpy as np
+import datetime
+from .pairwise_distances import pairwise_distances
+import importlib.resources
+
+def assign_types(fasta_data, user_input, model='p-distance', gap_deletion=True, threshold=0.405, 
+                 save_report=True, output_dir='reports', user_seq_names=None, distances_matrix=None):
+    """
+    Assigns types to query sequences based on p-distance to known prototypes.
+
+    Args:
+        fasta_data (pd.DataFrame): DataFrame from pairwise_distances input.
+        model (str): Distance model (default 'p-distance').
+        gap_deletion (bool): Whether to delete gaps (default True).
+        threshold (float): Max p-distance for assignment (default 0.105).
+        save_report (bool): If True, saves the output DataFrame to a CSV file.
+        output_dir (str): Directory to save the report (default 'reports').
+
+    Returns:
+        pd.DataFrame: A DataFrame with query, assignedType, distance, and reference.
+    """
+
+    # Read prototype sequences
+    try:
+        # Determine the correct prototype CSV file
+        user_input_cap = user_input.capitalize()
+        if user_input_cap == 'Vp1':
+            prototype_filename = 'vp1_test.csv'
+        elif user_input_cap == 'Vp4/2':
+            prototype_filename = 'prototypes.csv'
+        else:
+            raise ValueError("Invalid input. Please specify either 'Vp1' or 'Vp4/2'.")
+
+        # Use importlib.resources to access the data file
+        path_obj = importlib.resources.files('rhinotype.data').joinpath(prototype_filename)
+        with importlib.resources.as_file(path_obj) as path:
+            prototypes_df = pd.read_csv(path)
+            
+    except FileNotFoundError:
+        raise Exception("Error: Failed during genotype assignment. Prototypes file not found. Please check the file path.")
+    
+    names_to_keep = prototypes_df['Accession'].tolist()
+
+    # Run pairwiseDistances to calculate distances
+    if distances_matrix is not None:
+        print("Using pre-calculated distance matrix.")
+        distances = distances_matrix.copy() # Use the provided matrix
+    else:
+        print("Calculating pairwise distances for assign_types...")
+        # Run pairwiseDistances to calculate distances
+        distances = pairwise_distances(fasta_data, model=model, gap_deletion=gap_deletion)
+
+    # Filter columns based on the prototypes
+    distances = distances.loc[:, distances.columns.isin(names_to_keep)]
+
+    if user_seq_names is not None:
+        # We *only* want to classify the user's sequences.
+        print(f"Attempting to filter for {len(user_seq_names)} user-provided sequence names...")
+
+        # Get all valid names from the distance matrix (i.e., not prototypes)
+        all_mafft_names = [
+            idx_name for idx_name in distances.index 
+            if idx_name not in names_to_keep
+        ]
+
+        names_to_classify = []
+
+        # Loop through each of the user's original names
+        for original_name in user_seq_names:
+            found_match = False
+            # Loop through all the (potentially truncated) names from the MAFFT alignment
+            for mafft_name in all_mafft_names:
+                # Check if the MAFFT name *starts with* the user's original name
+                if mafft_name.startswith(original_name):
+                    names_to_classify.append(mafft_name)
+                    found_match = True
+                    break # Found a match, go to the next original_name
+
+            if not found_match:
+                print(f"Warning: Could not find a match for original name: {original_name}")
+
+        distances = distances.loc[names_to_classify, :]
+        print(f"Report filtered for {len(names_to_classify)} user-provided sequences.")
+
+    else:
+        # Fallback to old behavior if user_seq_names is not provided
+        print("Warning: No user_seq_names provided. Classifying all non-prototypes.")
+        distances = distances.loc[~distances.index.isin(names_to_keep), :]
+
+    # Initialize lists to store output data
+    query_vec = []
+    assigned_type_vec = []
+    distance_vec = []
+    ref_seq_vec = []
+
+    # Iterate over each row (query) in the distances DataFrame
+    for i, row in distances.iterrows():
+        query_header = i
+        valid_cols = row[row < threshold].index
+
+        if len(valid_cols) == 0:
+            # If no valid columns found, mark as "unassigned"
+            assigned_type_vec.append("unassigned")
+            distance_vec.append(np.nan)
+            # Find the column with the minimum distance
+            min_dist_col = row.idxmin()
+            ref_seq_vec.append(min_dist_col)
+        else:
+            # Choose the one with the minimum distance
+            min_distance_col = row[valid_cols].idxmin()
+            assigned_type = min_distance_col
+            assigned_type_vec.append(assigned_type.replace("RV", "").split("_")[-1])
+            distance_vec.append(row[min_distance_col])
+            ref_seq_vec.append(assigned_type)
+
+        query_vec.append(query_header)
+
+    # Create a DataFrame from the results
+    output_df = pd.DataFrame({
+        'query': query_vec,
+        'assignedType': assigned_type_vec,
+        'distance': distance_vec,
+        'reference': ref_seq_vec
+    })
+
+    # --- Save Report ---
+    if save_report:
+        try:
+            # Create the output directory if it doesn't exist
+            os.makedirs(output_dir, exist_ok=True)
+            # Sanitize the region name for the filename (replaces '/' with '_')
+            region_name = user_input.capitalize().replace('/', '_')
+            # Create a timestamp
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            # Define the filename
+            filename = f"classification_report_{region_name}_{timestamp}.csv"
+            # Define the full save path
+            save_path = os.path.join(output_dir, filename)
+            # Save the DataFrame to a CSV file
+            output_df.to_csv(save_path, index=False)
+            print(f"Classification report successfully saved to: {save_path}")
+        except Exception as e:
+            print(f"Error saving report: {e}")
+
+    return output_df
+
+if __name__ == "__main__":
+    assign_types() 

rhinotype-1.0.0/src/rhinotype/count_SNPs.py

@@ -0,0 +1,10 @@
+from .genetic_distances import count_snps_helper
+
+def count_snp(fasta_data, gap_deletion=True):
+    # run countSNP function
+    snps = count_snps_helper(fasta_data, gap_deletion=gap_deletion)
+    # output
+    return snps
+
+if __name__ == "__main__":
+    count_snp()