rdrpcatch 0.0.1__py3-none-any.whl

rdrpcatch/rdrpcatch_scripts/gui.py

@@ -0,0 +1,256 @@
+import tkinter as tk
+from tkinter import filedialog
+from tkinter import ttk
+import os
+import subprocess
+from tkinter import messagebox
+import polars as pl
+
+
+class colabscanner_gui:
+    def __init__(self):
+        self.root = tk.Tk()
+        self.root.title("RdRpCATCH")
+        self.root.geometry("1000x800")
+
+
+        style = ttk.Style(self.root)
+        # set theme style
+        style.theme_use("clam")
+
+        # Input file selection
+        self.input_frame = ttk.Frame(self.root)
+        self.input_frame.grid(row=0, column=0, columnspan=3, padx=5, pady=5)
+
+        self.input_label = ttk.Label(self.input_frame, text="Input File:")
+        self.input_label.pack(side=tk.LEFT)
+
+        self.input_entry = ttk.Entry(self.input_frame, width=50)
+        self.input_entry.pack(side=tk.LEFT, padx=5)
+
+        self.input_button = ttk.Button(self.input_frame, text="Browse", command=self.browse_input)
+        self.input_button.pack(side=tk.LEFT)
+
+        # Parent directory selection
+        self.parent_dir_frame = ttk.Frame(self.root)
+        self.parent_dir_frame.grid(row=1, column=0, columnspan=3, padx=5, pady=5)
+
+        self.parent_dir_label = ttk.Label(self.parent_dir_frame, text="Parent Directory:")
+        self.parent_dir_label.pack(side=tk.LEFT)
+
+        self.parent_dir_entry = ttk.Entry(self.parent_dir_frame, width=50)
+        self.parent_dir_entry.pack(side=tk.LEFT, padx=5)
+
+        self.parent_dir_button = ttk.Button(self.parent_dir_frame, text="Browse", command=self.browse_parent_dir)
+        self.parent_dir_button.pack(side=tk.LEFT)
+
+        # Output name entry
+        self.output_name_frame = ttk.Frame(self.root)
+        self.output_name_frame.grid(row=2, column=0, columnspan=3, padx=5, pady=5)
+
+        self.output_name_label = ttk.Label(self.output_name_frame, text="Output Name:")
+        self.output_name_label.pack(side=tk.LEFT)
+
+        self.output_name_entry = ttk.Entry(self.output_name_frame, width=50)
+        self.output_name_entry.pack(side=tk.LEFT, padx=5)
+
+        # HMM directory selection
+        self.hmm_dir_frame = ttk.Frame(self.root)
+        self.hmm_dir_frame.grid(row=3, column=0, columnspan=3, padx=5, pady=5)
+
+        self.hmm_dir_label = ttk.Label(self.hmm_dir_frame, text="HMM Directory:")
+        self.hmm_dir_label.pack(side=tk.LEFT)
+
+        self.hmm_dir_entry = ttk.Entry(self.hmm_dir_frame, width=50)
+        self.hmm_dir_entry.pack(side=tk.LEFT, padx=5)
+
+        self.hmm_dir_button = ttk.Button(self.hmm_dir_frame, text="Browse", command=self.browse_hmm_dir)
+        self.hmm_dir_button.pack(side=tk.LEFT)
+
+        # Database selection
+        self.db_frame = ttk.LabelFrame(self.root, text="Select Databases")
+        self.db_frame.grid(row=4, column=0, columnspan=3, padx=5, pady=10)
+
+        self.databases = {
+            'RVMT': tk.BooleanVar(),
+            'NeoRdRp': tk.BooleanVar(),
+            'NeoRdRp.2.1': tk.BooleanVar(),
+            'TSA_Olendraite_fam': tk.BooleanVar(),
+            'TSA_Olendraite_gen': tk.BooleanVar(),
+            'RDRP-scan': tk.BooleanVar(),
+            'Lucaprot': tk.BooleanVar()
+        }
+
+        for i, (db_name, var) in enumerate(self.databases.items()):
+            ttk.Checkbutton(self.db_frame, text=db_name, variable=var).grid(row=i//3, column=i%3, padx=5, pady=2)
+
+        # HMMsearch parameters
+        self.hmmsearch_frame = ttk.LabelFrame(self.root, text="HMMsearch Parameters")
+        self.hmmsearch_frame.grid(row=6, column=1, padx=5, pady=10)
+
+        self.hmmsearch_label = ttk.Label(self.hmmsearch_frame, text="HMMsearch Parameters:")
+        self.hmmsearch_label.pack(anchor=tk.W)
+
+        self.evalue_var = tk.StringVar(value='1e-05')
+        self.inc_evalue_var = tk.StringVar(value='1e-05')
+        self.dom_evalue_var = tk.StringVar(value='1e-05')
+        self.incdom_evalue_var = tk.StringVar(value='1e-05')
+        self.z_value_var = tk.IntVar(value=1000000)
+        self.cpus_var = tk.IntVar(value=1)
+
+        hmmsearch_params = [
+            ('E-value threshold', self.evalue_var),
+            ('Inclusion E-value threshold', self.inc_evalue_var),
+            ('Domain E-value threshold', self.dom_evalue_var),
+            ('Inclusion domain E-value threshold', self.incdom_evalue_var),
+            ('z-value', self.z_value_var),
+            ('Number of CPUs to use', self.cpus_var)
+        ]
+
+        for param_name, param_var in hmmsearch_params:
+            frame = ttk.Frame(self.hmmsearch_frame)
+            frame.pack(fill=tk.X, padx=5, pady=2)
+            ttk.Label(frame, text=param_name).pack(side=tk.LEFT)
+            ttk.Entry(frame, textvariable=param_var, width=15).pack(side=tk.RIGHT)
+
+        # seqkit translate parameters
+        self.seqkit_frame = ttk.Frame(self.root)
+        self.seqkit_frame.grid(row=6, column=2, padx=5, pady=10)
+        self.gen_code_var = tk.IntVar(value=1)
+        self.frame_var = tk.IntVar(value=6)
+        self.seqkit_translate_label = ttk.Label(self.seqkit_frame, text="Seqkit Translate Parameters:")
+        self.seqkit_translate_label.pack(anchor=tk.W)
+        seqkit_transl_params = [ ('Genetic code', self.gen_code_var), ('Frame (6: All frames)', self.frame_var)]
+        for param_name, param_var in seqkit_transl_params:
+            frame = ttk.Frame(self.seqkit_frame)
+            frame.pack(fill=tk.X, padx=5, pady=2)
+            ttk.Label(frame, text=param_name).pack(side=tk.LEFT)
+            ttk.Entry(frame, textvariable=param_var, width=15).pack(side=tk.RIGHT)
+
+        # Run button
+        self.run_button = ttk.Button(self.root, text="Run Script", command=self.run_script)
+        self.run_button.grid(row=7, column=1, padx=5, pady=5)
+
+        # Status label
+        self.status_label = tk.Label(self.root, text="", wraplength=400)
+        self.status_label.grid(row=9, column=0, columnspan=3, padx=5, pady=5)
+
+        # Progress text box (wider version)
+        self.progress_frame = ttk.Frame(self.root)
+        self.progress_frame.grid(row=8, column=0, columnspan=3, padx=5, pady=10)
+
+        self.progress_label = ttk.Label(self.progress_frame, text="Progress:")
+        self.progress_label.pack(anchor=tk.W)
+
+        # Make the text area wider
+        self.progress_text = tk.Text(self.progress_frame, height=15, width=120)
+        self.progress_text.pack(fill=tk.BOTH, expand=True)
+        self.progress_text.config(state='disabled')
+
+        # Add horizontal scrollbar
+        self.scrollbar_x = ttk.Scrollbar(self.progress_frame, orient=tk.HORIZONTAL)
+        self.scrollbar_x.pack(side=tk.BOTTOM, fill=tk.X)
+        self.progress_text.config(xscrollcommand=self.scrollbar_x.set)
+        self.scrollbar_x.config(command=self.progress_text.xview)
+
+        # Vertical scrollbar (already added earlier)
+        self.scrollbar = ttk.Scrollbar(self.progress_frame)
+        self.scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        self.progress_text.config(yscrollcommand=self.scrollbar.set)
+        self.scrollbar.config(command=self.progress_text.yview)
+
+    def browse_input(self):
+        filename = filedialog.askopenfilename()
+        self.input_entry.delete(0, tk.END)
+        self.input_entry.insert(0, filename)
+
+    def browse_parent_dir(self):
+        dirname = filedialog.askdirectory()
+        self.parent_dir_entry.delete(0, tk.END)
+        self.parent_dir_entry.insert(0, dirname)
+
+    def browse_hmm_dir(self):
+        dirname = filedialog.askdirectory()
+        self.hmm_dir_entry.delete(0, tk.END)
+        self.hmm_dir_entry.insert(0, dirname)
+
+    def run_script(self):
+        input_file = self.input_entry.get()
+        parent_dir = self.parent_dir_entry.get()
+        output_name = self.output_name_entry.get()
+        hmm_dir = self.hmm_dir_entry.get()
+
+        selected_dbs = [db for db, var in self.databases.items() if var.get()]
+
+        if not os.path.isfile(input_file):
+            self.status_label.config(text="Error: Input file does not exist.", fg="red")
+            return
+
+        if not os.path.isdir(parent_dir):
+            self.status_label.config(text="Error: Parent directory does not exist.", fg="red")
+            return
+
+        output_dir = os.path.join(parent_dir, output_name)
+
+        try:
+            os.makedirs(output_dir, exist_ok=True)
+        except Exception as e:
+            self.status_label.config(text=f"Error creating output directory: {str(e)}", fg="red")
+            return
+
+        db_options = ",".join(selected_dbs) if selected_dbs else "all"
+
+        hmmsearch_args = [
+            f'-e', self.evalue_var.get(),
+            f'-incE', self.inc_evalue_var.get(),
+            f'-domE', self.dom_evalue_var.get(),
+            f'-incdomE', self.incdom_evalue_var.get(),
+            f'-z', str(self.z_value_var.get()),
+            f'-cpus', str(self.cpus_var.get())
+        ]
+
+        try:
+            # Clear previous progress
+            self.clear_progress()
+
+            # Run the script
+            result = subprocess.Popen(
+                ["python3", "colabscanner.py", "-i", input_file, "-o", output_dir, "-hmm_dir", hmm_dir, "-dbs",
+                 db_options] + hmmsearch_args,
+                stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, universal_newlines=True)
+
+            # Read and display output line by line
+            for line in iter(result.stdout.readline, ""):
+                self.update_progress(line.strip())
+
+            result.wait()
+            if result.returncode == 0:
+                self.status_label.config(text="Script executed successfully.", fg="green")
+            else:
+                self.status_label.config(text="Script execution failed.", fg="red")
+
+        except Exception as e:
+            messagebox.showerror("Error", f"An unexpected error occurred:\n{str(e)}")
+            print(f"Unexpected error: {e}")
+
+    def clear_progress(self):
+        self.progress_text.config(state='normal')
+        self.progress_text.delete('1.0', tk.END)
+        self.progress_text.config(state='disabled')
+
+    def update_progress(self, message):
+        self.progress_text.config(state='normal')
+        self.progress_text.insert(tk.END, message + "\n")
+        self.progress_text.yview(tk.END)
+        self.progress_text.config(state='disabled')
+        self.root.update_idletasks()
+
+    def run(self):
+        self.root.mainloop()
+
+
+if __name__ == "__main__":
+    gui = colabscanner_gui()
+    gui.run()
+
+

rdrpcatch/rdrpcatch_scripts/mmseqs_tax.py

@@ -0,0 +1,100 @@
+import subprocess
+import os
+
+
+
+class mmseqs:
+
+    def __init__(self,fasta_fn, mmseqs_db, mmseqs_out_prefix,outdir_path, sens, cpus, log_file):
+        self.fasta_fn = fasta_fn
+        self.mmseqs_db = mmseqs_db
+        self.out_prefix = mmseqs_out_prefix
+        self.outdir_path = outdir_path
+        self.sens = sens
+        self.cpus = cpus
+        self.log_file = log_file
+
+    def run_mmseqs_easy_tax_lca(self):
+        """Run mmseqs easy-tax command."""
+
+        mmseqs_easy_tax_cmd = ["mmseqs",
+                               "easy-taxonomy",
+                               str(self.fasta_fn),
+                               str(self.mmseqs_db),
+                               str(self.out_prefix),
+                               f"{str(self.outdir_path)}/tmp",
+                               "--tax-lineage",
+                               "1",
+                               "--alignment-mode",
+                               "3",
+                               "-s",
+                               str(self.sens),
+                               "--threads",
+                               str(self.cpus)
+                               ]
+
+        try:
+            with open(self.log_file, 'w') as fout:
+                subprocess.run(mmseqs_easy_tax_cmd, stdout=fout, stderr=fout, shell=False, check=True)
+
+        except subprocess.CalledProcessError as e:
+            cmd_str = ' '.join(mmseqs_easy_tax_cmd)
+            raise Exception(f"Error running mmseqs easy-tax command: {cmd_str}")
+
+
+    def run_mmseqs_easy_tax_tophit(self):
+
+
+        mmseqs_easy_tax_cmd = ["mmseqs",
+                               "easy-taxonomy",
+                                 self.fasta_fn,
+                                    self.mmseqs_db,
+                                    self.out_prefix,
+                                    "tmp",
+                                    "--tax-lineage",
+                                    "1",
+                                    self.sens,
+                                    "--threads",
+                                    str(self.cpus),
+                                    "--lca-mode",
+                                    4]
+        try:
+            with open(self.log_file, 'w') as fout:
+                subprocess.run(mmseqs_easy_tax_cmd, stdout=fout, stderr=fout, shell=False, check=True)
+
+        except subprocess.CalledProcessError as e:
+            cmd_str = ' '.join(mmseqs_easy_tax_cmd)
+            raise Exception(f"Error running mmseqs easy-tax command: {cmd_str}")
+
+
+    def run_mmseqs_e_search(self):
+        mmseqs_e_search_cmd = ["mmseqs",
+                               "easy-search",
+                               str(self.fasta_fn),
+                               str(self.mmseqs_db),
+                               str(self.outdir_path),
+                               f"{str(self.out_prefix)}/tmp",
+                               "--start-sens",
+                               str(self.sens),
+                               "--threads",
+                               str(self.cpus),
+                               "--format-output",
+                               "query,target,fident,alnlen,mismatch,gapopen,"
+                               "qstart,qend,tstart,tend,evalue,bits,qcov,tcov,taxlineage",
+                               "--sort-results",
+                               "1"]
+        try:
+            with open(self.log_file, 'w') as fout:
+                subprocess.run(mmseqs_e_search_cmd, stdout=fout, stderr=fout, shell=False, check=True)
+
+        except subprocess.CalledProcessError as e:
+            cmd_str = ' '.join(mmseqs_e_search_cmd)
+            raise Exception(f"Error running mmseqs easy-search command: {cmd_str}")
+
+
+
+
+
+
+
+

rdrpcatch/rdrpcatch_scripts/paths.py

@@ -0,0 +1,162 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class classproperty(property):
+    def __get__(self, cls, owner):
+        return classmethod(self.fget).__get__(None, owner)()
+
+@dataclass
+class rdrpcatch_input:
+
+    #TODO: Change this line for final version
+
+    source_dir : Path = Path(__file__).parents[0].parents[0].parents[0]
+
+
+    @classproperty
+    def db_dir(cls):
+        return cls.source_dir / 'DBs'
+
+    @classproperty
+    def hmm_dbs_dir(cls):
+        return cls.source_dir / 'DBs'/ 'hmm_dbs'
+
+
+    @classproperty
+    def test_dir(cls):
+        return cls.source_dir / 'test'
+
+
+    @classproperty
+    def input_fasta(cls):
+        return cls.source_dir / "input.fasta"
+
+
+@dataclass
+class rdrpcatch_output:
+
+    prefix: str
+    output_dir: Path
+
+    @property
+    def tmp_dir(self):
+        return self.output_dir / "tmp"
+
+    @property
+    def hmm_output_dir (self):
+        return self.tmp_dir /"hmm_output"
+
+    def hmm_output_path(self, db_name):
+        return self.hmm_output_dir / f"{self.prefix}_{db_name}_hmmsearch_output.txt"
+
+    @property
+    def formatted_hmm_output_dir(self):
+        return self.tmp_dir / "formatted_hmm_output"
+
+    def formatted_hmm_output_path(self, db_name):
+        return self.formatted_hmm_output_dir / f"{self.prefix}_{db_name}_hmm_output_formatted.txt"
+
+    @property
+    def best_hit_dir(self):
+        return self.tmp_dir / "best_hit_hmm_output"
+
+    def best_hit_path(self, db_name):
+        return self.best_hit_dir / f"{self.prefix}_{db_name}_hmm_output_best_hit.txt"
+
+    @property
+    def seqkit_seq_output_dir(self):
+        return self.tmp_dir/ "seqkit_seq_output"
+
+    @property
+    def seqkit_seq_output_path(self):
+        return self.seqkit_seq_output_dir / f"{self.prefix}_seqkit_seq_output.fasta"
+
+    @property
+    def seqkit_translate_output_dir(self):
+        return self.tmp_dir/ "seqkit_translate_output"
+
+    @property
+    def seqkit_translate_output_path(self):
+        return self.seqkit_translate_output_dir / f"{self.prefix}_seqkit_translate_output.fasta"
+
+
+    @property
+    def tsv_outdir(self):
+        return self.tmp_dir/ "tsv_files"
+    @property
+    def combined_tsv_path(self):
+        return self.tsv_outdir / f"{self.prefix}_combined.tsv"
+
+    @property
+    def mmseqs_tax_output_dir(self ):
+        return self.tmp_dir/ "mmseqs_tax_output"
+
+    @property
+    def mmseqs_tax_output_prefix(self):
+        return self.mmseqs_tax_output_dir / f"{self.prefix}_mmseqs_tax"
+
+    @property
+    def mmseqs_tax_log_path(self):
+        return self.log_dir / f"{self.prefix}_mmseqs_tax.log"
+
+    @property
+    def mmseqs_tax_output_lca_path(self):
+        return self.mmseqs_tax_output_dir / f"{self.prefix}_mmseqs_tax_lca.tsv"
+    @property
+    def mmseqs_e_search_output_dir(self):
+        return self.tmp_dir/ "mmseqs_e_search_output"
+    @property
+    def mmseqs_e_search_log_path(self):
+        return self.log_dir/ f"{self.prefix}_mmseqs_e_search.log"
+    @property
+    def mmseqs_e_search_output_prefix(self):
+        return self.mmseqs_e_search_output_dir / f"{self.prefix}_mmseqs_e_search"
+
+    @property
+    def mmseqs_e_search_output_path(self):
+        return self.mmseqs_e_search_output_dir / f"{self.prefix}_mmseqs_e_search.tsv"
+
+
+    @property
+    def plot_outdir(self):
+        return self.output_dir / f"{self.prefix}_rdrpcatch_plots"
+
+    @property
+    def fasta_output_dir(self):
+        return self.output_dir / f"{self.prefix}_rdrpcatch_fasta"
+
+    @property
+    def fasta_nuc_out_path(self):
+        return self.fasta_output_dir / f"{self.prefix}_full_nucleotide_contigs.fasta"
+
+    @property
+    def fasta_trimmed_out_path(self):
+        return self.fasta_output_dir / f"{self.prefix}_trimmed_aminoacid_contigs.fasta"
+
+    @property
+    def fasta_prot_out_path(self):
+        return self.fasta_output_dir / f"{self.prefix}_full_aminoacid_contigs.fasta"
+
+    @property
+    def rdrpcatch_output(self):
+        return self.tsv_outdir / f"{self.prefix}_rdrpcatch_output.tsv"
+
+    @property
+    def extended_rdrpcatch_output(self):
+        return self.output_dir / f"{self.prefix}_rdrpcatch_output_annotated.tsv"
+    @property
+    def log_dir(self):
+        return self.tmp_dir / f"{self.prefix}_logs"
+    @property
+    def log_file(self):
+        return self.log_dir / f"{self.prefix}_rdrpcatch.log"
+    @property
+    def gff_output_dir(self):
+        return self.output_dir / f"{self.prefix}_gff_files"
+    @property
+    def gff_output_path(self):
+        return self.gff_output_dir / f"{self.prefix}_full_aminoacid_rdrpcatch.gff3"
+
+
+

rdrpcatch/rdrpcatch_scripts/plot.py

@@ -0,0 +1,165 @@
+import warnings
+# Filter numpy warnings before any imports that might trigger them
+warnings.filterwarnings("ignore", category=UserWarning, module="numpy")
+warnings.filterwarnings("ignore", category=RuntimeWarning, module="numpy")
+warnings.filterwarnings("ignore", message=".*subnormal.*")
+
+class Plotter:
+
+    def __init__(self,  upset_outdir, tsv_outdir, prefix):
+        self.upset_outdir = upset_outdir
+        self.tsv_outdir = tsv_outdir
+        self.prefix = prefix
+
+    def upset_plotter(self, analysis_dict):
+        ''' Create an upset plot for the analysis results for a given e-value threshold
+
+        :param analysis_dict:
+        :param general_outdir:
+        :param eval:
+        :return:
+
+        '''
+        from matplotlib import pyplot as plt
+        import upsetplot
+        import os
+
+        upset_data = upsetplot.from_contents(analysis_dict)
+        # write upset data to a tsv file
+        upset_data.to_csv(os.path.join(self.tsv_outdir, f"{self.prefix}_upset_data.tsv"), sep="\t")
+        upsetplot.UpSet(upset_data, subset_size="count", show_counts=True, sort_by='cardinality').plot()
+        plt.savefig(os.path.join(self.upset_outdir, f"{self.prefix}_upset_plot.png"), bbox_inches='tight', dpi=300)
+        plt.close()
+
+    # def plot_evalue(self, combined_df):
+    #
+    #     sns.set(style="whitegrid")
+    #     plt.figure(figsize=(10, 6))
+    #     ax = sns.boxplot(x='db_name', y='E-value', data=combined_df, showfliers=False)
+    #     plt.title(f"E-value distribution", fontweight='bold')
+    #     plt.savefig(os.path.join(self.upset_outdir, f"{self.prefix}_evalue_plot.png"), bbox_inches='tight', dpi=300)
+    #     plt.close()
+
+    def plot_evalue(self, combined_df):
+        import polars as pl
+        import altair as alt
+        import os
+        
+        # Ensure the E-value column contains only positive numbers and convert to log scale
+        df = combined_df.filter(pl.col('E-value') > 0).with_columns([
+            pl.col('E-value').log10().alias('log10_evalue')
+        ])
+        
+        chart = alt.Chart(df).mark_boxplot().encode(
+            x=alt.X('db_name:N', title='Database'),
+            y=alt.Y('log10_evalue:Q', title='log10(E-value)'),
+            color='db_name:N'
+        ).properties(
+            title='E-value Distribution',
+            width=600,
+            height=400
+        )
+        
+        chart.save(os.path.join(self.upset_outdir, f"{self.prefix}_evalue_plot.html"))
+
+    def plot_score(self, combined_df):
+        import altair as alt
+        import os
+        
+        chart = alt.Chart(combined_df).mark_boxplot().encode(
+            x=alt.X('db_name:N', title='Database'),
+            y=alt.Y('score:Q', title='Score'),
+            color='db_name:N'
+        ).properties(
+            title='Score Distribution',
+            width=600,
+            height=400
+        )
+        
+        chart.save(os.path.join(self.upset_outdir, f"{self.prefix}_score_plot.html"))
+
+    def plot_norm_bitscore_profile(self, combined_df):
+        import altair as alt
+        import os
+        
+        chart = alt.Chart(combined_df).mark_boxplot().encode(
+            x=alt.X('db_name:N', title='Database'),
+            y=alt.Y('norm_bitscore_profile:Q', title='Normalized Bitscore (Profile)'),
+            color='db_name:N'
+        ).properties(
+            title='Normalized Bitscore Distribution (Profile)',
+            width=600,
+            height=400
+        )
+        
+        chart.save(os.path.join(self.upset_outdir, f"{self.prefix}_norm_bitscore_plot_profile.html"))
+
+    def plot_norm_bitscore_contig(self, combined_df):
+        import altair as alt
+        import os
+        
+        chart = alt.Chart(combined_df).mark_boxplot().encode(
+            x=alt.X('db_name:N', title='Database'),
+            y=alt.Y('norm_bitscore_contig:Q', title='Normalized Bitscore (Contig)'),
+            color='db_name:N'
+        ).properties(
+            title='Normalized Bitscore Distribution (Contig)',
+            width=600,
+            height=400
+        )
+        
+        chart.save(os.path.join(self.upset_outdir, f"{self.prefix}_norm_bitscore_contig_plot.html"))
+
+    def plot_ID_score(self, combined_df):
+        import altair as alt
+        import os
+        
+        chart = alt.Chart(combined_df).mark_boxplot().encode(
+            x=alt.X('db_name:N', title='Database'),
+            y=alt.Y('ID_score:Q', title='Identity Score'),
+            color='db_name:N'
+        ).properties(
+            title='Identity Score Distribution',
+            width=600,
+            height=400
+        )
+        
+        chart.save(os.path.join(self.upset_outdir, f"{self.prefix}_ID_score_plot.html"))
+
+    def plot_profile_coverage(self, combined_df):
+        import altair as alt
+        import os
+        
+        chart = alt.Chart(combined_df).mark_boxplot().encode(
+            x=alt.X('db_name:N', title='Database'),
+            y=alt.Y('profile_coverage:Q', title='Profile Coverage'),
+            color='db_name:N'
+        ).properties(
+            title='Profile Coverage Distribution',
+            width=600,
+            height=400
+        )
+        
+        chart.save(os.path.join(self.upset_outdir, f"{self.prefix}_profile_coverage_plot.html"))
+
+    def plot_contig_coverage(self, combined_df):
+        import altair as alt
+        import os
+        
+        chart = alt.Chart(combined_df).mark_boxplot().encode(
+            x=alt.X('db_name:N', title='Database'),
+            y=alt.Y('contig_coverage:Q', title='Contig Coverage'),
+            color='db_name:N'
+        ).properties(
+            title='Contig Coverage Distribution',
+            width=600,
+            height=400
+        )
+        
+        chart.save(os.path.join(self.upset_outdir, f"{self.prefix}_contig_coverage_plot.html"))
+
+
+
+
+
+