Delete ml_simplified_tree.py

ml_simplified_tree.py

@@ -1,2026 +0,0 @@
-# -*- coding: utf-8 -*-
-"""ML simplified tree.ipynb
-
-Automatically generated by Colab.
-
-Original file is located at
-    https://colab.research.google.com/drive/1LiDjip-h70ilIex9PedpWCZARWglija7
-"""
-
-
-# Commented out IPython magic to ensure Python compatibility.
-import pandas as pd
-import numpy as np
-import plotly.graph_objects as go
-import plotly.offline as pyo
-from plotly.subplots import make_subplots
-from Bio import Phylo, SeqIO, AlignIO
-from Bio.Phylo.TreeConstruction import DistanceCalculator, DistanceTreeConstructor
-from Bio.Align import MultipleSeqAlignment
-from Bio.Seq import Seq
-from Bio.SeqRecord import SeqRecord
-from sklearn.feature_extraction.text import CountVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import LabelEncoder
-import warnings
-import os
-import sys
-from typing import Dict, List, Tuple, Optional, Any
-import json
-import re
-from scipy.optimize import minimize
-from scipy.spatial.distance import pdist, squareform
-from Bio.Phylo import BaseTree
-import itertools
-from collections import defaultdict, deque
-import argparse
-import time
-from pathlib import Path
-
-warnings.filterwarnings('ignore')
-
-class PhylogeneticTreeAnalyzer:
-
-    def __init__(self):
-
-        self.data = None
-        self.query_sequence = None
-        self.query_id = None
-        self.matching_percentage = 95.0
-        self.actual_percentage = None
-        self.matched_sequences = []
-        self.tree_structure = {}
-        self.similarity_scores = {}
-        self.ai_model = None
-        self.label_encoder = LabelEncoder()
-            # ML-specific attributes
-        self.ml_tree = None
-        self.ml_alignment = None
-        self.ml_results = {}
-        self.horizontal_line_tracker = []  # Track horizontal lines with verticals
-        self.query_ml_group = None  # Track which ML group contains the query
-        self.base_horizontal_length = 1.2  # Base length for horizontal lines
-
-    def load_data(self, data_file: str):
-
-        try:
-            self.data = pd.read_csv(data_file)
-            # required_columns = ['Accession Number', 'ML', 'Genotype', 'Host',
-            #                   'Country', 'Isolate', 'Year', 'F-gene']
-
-            # missing_columns = [col for col in self.data.columns if col not in required_columns] # Corrected check for missing columns
-            # if missing_columns:
-            #     print(f"Error: Missing required columns: {missing_columns}")
-            #     return False
-
-            print(f"✓ Data loaded successfully: {len(self.data)} sequences")
-            print(f"✓ ML Groups found: {self.data['ML'].nunique()}")
-            print(f"✓ Genotypes found: {self.data['Genotype'].nunique()}")
-            return True
-
-        except Exception as e:
-            print(f"Error loading data: {e}")
-            return False
-
-
-    def calculate_f_gene_similarity(self, seq1: str, seq2: str) -> float:
-
-        try:
-            # Handle empty or None sequences
-            if not seq1 or not seq2:
-                return 0.0
-
-            # Convert to uppercase and remove non-nucleotide characters
-            seq1 = re.sub(r'[^ATGC]', '', str(seq1).upper())
-            seq2 = re.sub(r'[^ATGC]', '', str(seq2).upper())
-
-            if len(seq1) == 0 or len(seq2) == 0:
-                return 0.0
-
-            # Use k-mer analysis for similarity calculation
-            k = 5  # 5-mer analysis
-            kmers1 = set([seq1[i:i+k] for i in range(len(seq1)-k+1) if len(seq1[i:i+k]) == k])
-            kmers2 = set([seq2[i:i+k] for i in range(len(seq2)-k+1) if len(seq2[i:i+k]) == k])
-
-            if len(kmers1) == 0 and len(kmers2) == 0:
-                return 100.0
-            elif len(kmers1) == 0 or len(kmers2) == 0:
-                return 0.0
-
-            # Calculate Jaccard similarity
-            intersection = len(kmers1.intersection(kmers2))
-            union = len(kmers1.union(kmers2))
-            similarity = (intersection / union) * 100 if union > 0 else 0.0
-
-            return round(similarity, 2)
-
-        except Exception as e:
-            print(f"Error calculating similarity: {e}")
-            return 0.0
-
-    def train_ai_model(self):
-
-        try:
-
-            # Skip training if insufficient data
-            if len(self.data) < 10:  # Require minimum 10 samples
-                print("⚠️ Insufficient data to train AI model (min 10 samples required)", flush=True)
-                return False
-
-            print("🤖 Training AI model for sequence analysis...", flush=True)
-
-            # Prepare features from F-gene sequences
-            f_gene_sequences = self.data['F-gene'].fillna('').astype(str)
-
-            # Create k-mer features (3-mers to 6-mers)
-            features = []
-            for seq in f_gene_sequences:
-                seq_clean = re.sub(r'[^ATGC]', '', seq.upper())
-                if len(seq_clean) < 3:
-                    features.append([0] * 100)  # Placeholder for short sequences
-                    continue
-
-                feature_vector = []
-                # 3-mers
-                kmers_3 = [seq_clean[i:i+3] for i in range(len(seq_clean)-2)]
-                kmer_counts_3 = {kmer: kmers_3.count(kmer) for kmer in set(kmers_3)}
-
-                # 4-mers
-                kmers_4 = [seq_clean[i:i+4] for i in range(len(seq_clean)-3)]
-                kmer_counts_4 = {kmer: kmers_4.count(kmer) for kmer in set(kmers_4)}
-
-                # Create feature vector (top 50 3-mers + top 50 4-mers)
-                all_3mers = [''.join(p) for p in __import__('itertools').product('ATGC', repeat=3)]
-                all_4mers = [''.join(p) for p in __import__('itertools').product('ATGC', repeat=4)]
-
-                feature_vector.extend([kmer_counts_3.get(kmer, 0) for kmer in all_3mers[:50]])
-                feature_vector.extend([kmer_counts_4.get(kmer, 0) for kmer in all_4mers[:50]])
-
-                features.append(feature_vector)
-
-            # Prepare target labels (ML groups)
-            targets = self.label_encoder.fit_transform(self.data['ML'].fillna('Unknown'))
-
-            # Skip if only 1 class
-            if len(np.unique(targets)) < 2:
-                print("⚠️ Need at least 2 distinct classes for training", flush=True)
-                return False
-
-            # Train Random Forest model
-            X = np.array(features)
-            y = targets
-
-            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-
-            self.ai_model = RandomForestClassifier(n_estimators=100, random_state=42)
-            self.ai_model.fit(X_train, y_train)
-
-            # Calculate accuracy
-            accuracy = self.ai_model.score(X_test, y_test)
-            print(f"✓ AI model trained successfully with accuracy: {accuracy:.2%}", flush=True)
-
-            return True
-
-        except Exception as e:
-            print(f"🚨 CRITICAL training error: {e}", flush=True)
-            import traceback
-            traceback.print_exc()
-            return False
-
-    def find_query_sequence(self, query_input: str) -> bool:
-        """
-        Modified to accept any sequence input, not just those existing in the dataset.
-        """
-        try:
-            # Check if input is an accession number from the dataset
-            if query_input in self.data['Accession Number'].values:
-                self.query_id = query_input
-                query_row = self.data[self.data['Accession Number'] == query_input].iloc[0]
-                self.query_sequence = query_row['F-gene']
-                print(f"✓ Query sequence found by ID: {query_input}")
-                return True
-
-            # Check if input is a nucleotide sequence
-            query_clean = re.sub(r'[^ATGC]', '', str(query_input).upper())
-
-            # Accept any sequence with reasonable length (even short ones for testing)
-            if len(query_clean) >= 10:  # Minimum sequence length (reduced from 50)
-                # For sequences not in dataset, create a unique identifier
-                if query_input not in self.data['Accession Number'].values:
-                    # Generate a unique query ID for novel sequences
-                    self.query_id = f"QUERY_{hash(query_clean) % 100000:05d}"
-                    self.query_sequence = query_clean
-                    print(f"✓ Novel query sequence accepted with ID: {self.query_id}")
-                    print(f"  Sequence length: {len(query_clean)} nucleotides")
-                    return True
-                else:
-                    # If somehow it matches an accession but wasn't caught above
-                    self.query_id = query_input
-                    self.query_sequence = query_clean
-                    print(f"✓ Query sequence processed: {query_input}")
-                    return True
-
-            # If sequence is too short or invalid
-            if len(query_clean) < 10:
-                print(f"✗ Query sequence too short. Minimum length: 10 nucleotides (provided: {len(query_clean)})")
-            else:
-                print(f"✗ Invalid sequence format. Please provide nucleotides (A, T, G, C) or valid accession number")
-
-            return False
-
-        except Exception as e:
-            print(f"Error processing query sequence: {e}")
-            return False
-
-    def find_similar_sequences(self, target_percentage: float) -> Tuple[List[str], float]:
-        """
-        Modified to work with any query sequence, including novel ones not in the dataset.
-        """
-        try:
-            print(f"🔍 Finding sequences with {target_percentage}% similarity to query...")
-            similarities = []
-
-            # Calculate similarity between query and all sequences in dataset
-            for idx, row in self.data.iterrows():
-                # Skip if this is the same sequence (only relevant for existing accession numbers)
-                if hasattr(self, 'query_id') and row['Accession Number'] == self.query_id:
-                    continue
-
-                try:
-                    similarity = self.calculate_f_gene_similarity(self.query_sequence, row['F-gene'])
-                    similarities.append({
-                        'id': row['Accession Number'],
-                        'similarity': similarity,
-                        'ml': row['ML'] if 'ML' in row else 'Unknown',
-                        'genotype': row['Genotype'] if 'Genotype' in row else 'Unknown'
-                    })
-                except Exception as seq_error:
-                    print(f"⚠ Skipping sequence {row['Accession Number']}: {seq_error}")
-                    continue
-
-            if not similarities:
-                print("❌ No valid sequences found for comparison")
-                return [], target_percentage
-
-            # Sort by similarity (highest first)
-            similarities.sort(key=lambda x: x['similarity'], reverse=True)
-
-            # Find sequences within target percentage range (±2%)
-            target_range = 2.0
-            candidates = [s for s in similarities
-                        if abs(s['similarity'] - target_percentage) <= target_range]
-
-            if not candidates:
-                # If no exact matches, find sequences with closest similarity
-                closest_sim = min(similarities, key=lambda x: abs(x['similarity'] - target_percentage))
-                actual_percentage = closest_sim['similarity']
-
-                # Get sequences within ±1% of the closest similarity
-                candidates = [s for s in similarities
-                            if abs(s['similarity'] - actual_percentage) <= 1.0]
-
-                print(f"⚠ No sequences found at exactly {target_percentage}%. Using closest: {actual_percentage:.1f}%")
-            else:
-                actual_percentage = target_percentage
-
-            # Limit results to prevent overwhelming visualization (optional)
-            max_results = 50  # Adjust as needed
-            if len(candidates) > max_results:
-                candidates = candidates[:max_results]
-                print(f"⚠ Limited results to top {max_results} matches for better visualization")
-
-            # Store similarity scores for later use
-            self.similarity_scores = {}  # Reset similarity scores
-            for candidate in candidates:
-                self.similarity_scores[candidate['id']] = candidate['similarity']
-
-            matched_ids = [c['id'] for c in candidates]
-
-            # Show some statistics
-            if similarities:
-                max_sim = max(similarities, key=lambda x: x['similarity'])['similarity']
-                min_sim = min(similarities, key=lambda x: x['similarity'])['similarity']
-                avg_sim = sum(s['similarity'] for s in similarities) / len(similarities)
-
-                print(f"✓ Found {len(matched_ids)} sequences at ~{actual_percentage:.1f}% similarity")
-                print(f"  Similarity range in dataset: {min_sim:.1f}% - {max_sim:.1f}% (avg: {avg_sim:.1f}%)")
-
-            return matched_ids, actual_percentage
-
-        except Exception as e:
-            print(f"Error finding similar sequences: {e}")
-            return [], target_percentage
-
-
-    def build_tree_structure(self, matched_ids: List[str]) -> Dict:
-            try:
-                print("🌳 Building normalized horizontal tree structure...")
-
-                # Initialize tree structure
-                tree_structure = {
-                    'root': {
-                        'name': 'Root',
-                        'type': 'root',
-                        'children': {},
-                        'x': 0,
-                        'y': 0,
-                        'has_vertical_attachment': False,
-                        'extension_level': 0
-                    }
-                }
-
-                # Group sequences by ML and Genotype
-                ml_groups = {}
-                for idx, row in self.data.iterrows():
-                    ml_group = row['ML']
-                    genotype = row['Genotype']
-                    seq_id = row['Accession Number']
-
-                    if ml_group not in ml_groups:
-                        ml_groups[ml_group] = {}
-
-                    if genotype not in ml_groups[ml_group]:
-                        ml_groups[ml_group][genotype] = []
-
-                    ml_groups[ml_group][genotype].append({
-                        'id': seq_id,
-                        'data': row.to_dict(),
-                        'is_query': seq_id == self.query_id,
-                        'is_matched': seq_id in matched_ids,
-                        'similarity': self.similarity_scores.get(seq_id, 0.0)
-                    })
-
-                # Normalize ML group names and organize
-                normalized_ml_groups = self._normalize_ml_groups(ml_groups)
-
-                # Build normalized ML level - horizontal layout with progressive extensions
-                self._build_normalized_ml_nodes(tree_structure, normalized_ml_groups, matched_ids)
-
-                self.tree_structure = tree_structure
-                print(f"✓ Normalized horizontal tree structure built")
-                return tree_structure
-
-            except Exception as e:
-                print(f"Error building tree structure: {e}")
-                return {}
-
-    def _normalize_ml_groups(self, ml_groups: Dict) -> Dict:
-        """Normalize ML group names and organize hierarchically"""
-        try:
-            normalized_groups = {}
-
-            for ml_name, genotypes in ml_groups.items():
-                # Extract base ML name
-                if ml_name.startswith('UNCL'):
-                    base_ml = 'UNCL'
-                elif '.' in ml_name and any(char.isdigit() for char in ml_name):
-                    # For names like XII.1.2, XII.1, etc., extract the base (XII)
-                    base_ml = ml_name.split('.')[0]
-                else:
-                    base_ml = ml_name
-
-                # Initialize normalized group structure
-                if base_ml not in normalized_groups:
-                    normalized_groups[base_ml] = {
-                        'full_ml_groups': {},
-                        'representative_sequences': [],
-                        'has_special_sequences': False
-                    }
-
-                # Check if this ML group has query or matched sequences
-                has_special = any(
-                    any(seq['is_query'] or seq['is_matched'] for seq in sequences)
-                    for sequences in genotypes.values()
-                )
-
-                if has_special:
-                    normalized_groups[base_ml]['has_special_sequences'] = True
-                    normalized_groups[base_ml]['full_ml_groups'][ml_name] = genotypes
-                else:
-                    # Add as representative (limit to 2 representatives)
-                    if len(normalized_groups[base_ml]['representative_sequences']) < 2:
-                        # Get 1-2 representative sequences from this ML group
-                        for genotype, sequences in list(genotypes.items())[:2]:
-                            if len(normalized_groups[base_ml]['representative_sequences']) < 2:
-                                normalized_groups[base_ml]['representative_sequences'].extend(sequences[:1])
-
-            return normalized_groups
-
-        except Exception as e:
-            print(f"Error normalizing ML groups: {e}")
-            return {}
-
-    def _build_normalized_ml_nodes(self, tree_structure: Dict, normalized_ml_groups: Dict, matched_ids: List[str]):
-        """Build normalized ML nodes with equal spacing and progressive horizontal extensions"""
-        try:
-            # Reset horizontal line tracker
-            self.horizontal_line_tracker = []
-
-            # Identify which ML group contains the query
-            self._identify_query_ml_group(normalized_ml_groups)
-
-            # Calculate equal spacing for all ML groups
-            ml_positions = self._calculate_dynamic_ml_positions(normalized_ml_groups)
-
-            # Mark root as having vertical attachment if it has multiple children
-            root_has_vertical = len(normalized_ml_groups) > 1
-            tree_structure['root']['has_vertical_attachment'] = root_has_vertical
-
-            for ml_idx, (base_ml, ml_data) in enumerate(normalized_ml_groups.items()):
-                y_pos = ml_positions[ml_idx]
-
-                # Determine if this ML node will have vertical attachments
-                has_vertical = ml_data['has_special_sequences'] and len(ml_data['full_ml_groups']) > 1
-
-                # Check if this ML group contains the query
-                contains_query = (base_ml == self.query_ml_group)
-
-                # Calculate horizontal line length based on connections and query presence
-                horizontal_length = self._determine_horizontal_line_length(
-                    'normalized_ml_group', has_vertical, contains_query
-                )
-
-                x_pos = horizontal_length
-
-                # Create normalized ML node
-                tree_structure['root']['children'][base_ml] = {
-                    'name': base_ml,
-                    'type': 'normalized_ml_group',
-                    'children': {},
-                    'x': x_pos,
-                    'y': y_pos,
-                    'has_special_sequences': ml_data['has_special_sequences'],
-                    'has_vertical_attachment': has_vertical,
-                    'horizontal_line_length': horizontal_length,
-                    'contains_query': contains_query
-                }
-
-                if ml_data['has_special_sequences']:
-                    # Build full ML nodes for groups with special sequences
-                    self._build_full_ml_nodes(
-                        tree_structure['root']['children'][base_ml],
-                        ml_data['full_ml_groups'],
-                        y_pos,
-                        matched_ids,
-                        x_pos
-                    )
-                else:
-                    # Add representative sequences directly
-                    self._add_representative_sequences(
-                        tree_structure['root']['children'][base_ml],
-                        ml_data['representative_sequences'],
-                        y_pos,
-                        x_pos
-                    )
-
-        except Exception as e:
-            print(f"Error building normalized ML nodes: {e}")
-
-    def _calculate_dynamic_ml_positions(self, normalized_ml_groups: Dict) -> List[float]:
-        """Calculate equal Y positions for all ML groups regardless of content"""
-        try:
-            ml_count = len(normalized_ml_groups)
-            if ml_count == 0:
-                return []
-
-            if ml_count == 1:
-                return [0.0]
-
-            # Equal spacing between all ML nodes
-            total_spacing = (ml_count - 1) * 2.0  # 2.0 units between each ML node
-            start_y = -total_spacing / 2
-
-            positions = []
-            for i in range(ml_count):
-                positions.append(start_y + i * 2.0)
-
-            return positions
-
-        except Exception as e:
-            print(f"Error calculating dynamic positions: {e}")
-            return list(range(len(normalized_ml_groups)))
-
-    def _build_full_ml_nodes(self, normalized_ml_node: Dict, full_ml_groups: Dict, base_y: float, matched_ids: List[str], parent_x: float):
-        """Build full ML nodes with genotypes for groups containing special sequences"""
-        try:
-            # Calculate equal positions for full ML groups
-            full_ml_positions = self._calculate_full_ml_positions(full_ml_groups, base_y)
-
-            for ml_idx, (full_ml_name, genotypes) in enumerate(full_ml_groups.items()):
-                y_pos = full_ml_positions[ml_idx]
-
-                # Determine if this full ML node will have vertical attachments
-                special_genotypes_count = sum(1 for genotype, sequences in genotypes.items()
-                                            if any(seq['is_query'] or seq['is_matched'] for seq in sequences))
-                has_vertical = special_genotypes_count > 1
-
-                # Check if this full ML group contains the query
-                contains_query = any(
-                    any(seq['is_query'] for seq in sequences)
-                    for sequences in genotypes.values()
-                )
-
-                # Calculate horizontal line length
-                horizontal_length = self._determine_horizontal_line_length(
-                    'full_ml_group', has_vertical, contains_query
-                )
-
-                x_pos = parent_x + horizontal_length
-
-                # Create full ML node
-                normalized_ml_node['children'][full_ml_name] = {
-                    'name': full_ml_name,
-                    'type': 'full_ml_group',
-                    'children': {},
-                    'x': x_pos,
-                    'y': y_pos,
-                    'sequences_count': sum(len(seqs) for seqs in genotypes.values()),
-                    'has_vertical_attachment': has_vertical,
-                    'horizontal_line_length': horizontal_length,
-                    'contains_query': contains_query
-                }
-
-                # Build genotype nodes
-                self._build_genotype_nodes(
-                    normalized_ml_node['children'][full_ml_name],
-                    genotypes,
-                    y_pos,
-                    matched_ids,
-                    x_pos
-                )
-
-        except Exception as e:
-            print(f"Error building full ML nodes: {e}")
-
-    def _calculate_full_ml_positions(self, full_ml_groups: Dict, base_y: float) -> List[float]:
-        """Calculate equal positions for full ML groups"""
-        try:
-            ml_count = len(full_ml_groups)
-            if ml_count <= 1:
-                return [base_y]
-
-            # Equal spacing for full ML groups
-            spacing = 1.5  # Fixed spacing between full ML groups
-            start_y = base_y - (spacing * (ml_count - 1)) / 2
-
-            positions = []
-            for i in range(ml_count):
-                positions.append(start_y + i * spacing)
-
-            return positions
-
-        except Exception as e:
-            print(f"Error calculating full ML positions: {e}")
-            return [base_y] * len(full_ml_groups)
-
-    def _build_genotype_nodes(self, full_ml_node: Dict, genotypes: Dict, base_y: float, matched_ids: List[str], parent_x: float):
-        """Build genotype nodes with sequences - horizontal line length based on sequence count"""
-        try:
-            # Filter genotypes with special sequences
-            special_genotypes = []
-            for genotype, sequences in genotypes.items():
-                if any(seq['is_query'] or seq['is_matched'] for seq in sequences):
-                    special_genotypes.append((genotype, sequences))
-
-            if not special_genotypes:
-                return
-
-            # Calculate equal genotype positions (vertical positioning remains equal)
-            genotype_positions = self._calculate_genotype_positions(special_genotypes, base_y)
-
-            # Calculate sequence counts for each genotype to determine horizontal line lengths
-            genotype_sequence_counts = []
-            for genotype, sequences in special_genotypes:
-                special_sequences = [seq for seq in sequences if seq['is_query'] or seq['is_matched']]
-                genotype_sequence_counts.append((genotype, sequences, len(special_sequences)))
-
-            for gt_idx, (genotype, sequences, sequence_count) in enumerate(genotype_sequence_counts):
-                y_pos = genotype_positions[gt_idx]
-
-                # Determine if this genotype will have vertical attachments
-                special_sequences = [seq for seq in sequences if seq['is_query'] or seq['is_matched']]
-                has_vertical = len(special_sequences) > 1
-
-                # Check if this genotype contains the query
-                contains_query = any(seq['is_query'] for seq in sequences)
-
-                # Calculate horizontal line length based on sequence count
-                horizontal_length = self._determine_genotype_horizontal_line_length(
-                    sequence_count, has_vertical, contains_query
-                )
-
-                x_pos = parent_x + horizontal_length
-
-                # Create genotype node
-                full_ml_node['children'][genotype] = {
-                    'name': genotype,
-                    'type': 'genotype',
-                    'children': {},
-                    'x': x_pos,
-                    'y': y_pos,
-                    'sequences': sequences,
-                    'has_vertical_attachment': has_vertical,
-                    'horizontal_line_length': horizontal_length,
-                    'contains_query': contains_query,
-                    'sequence_count': sequence_count  # Store for reference
-                }
-
-                # Add sequences horizontally
-                self._add_sequences_horizontal(
-                    full_ml_node['children'][genotype],
-                    sequences,
-                    y_pos,
-                    x_pos
-                )
-
-        except Exception as e:
-            print(f"Error building genotype nodes: {e}")
-
-    def _determine_genotype_horizontal_line_length(self, sequence_count: int, has_vertical: bool, contains_query: bool = False) -> float:
-        """Determine horizontal line length for genotype nodes based on sequence count"""
-        try:
-            base_length = self.base_horizontal_length
-
-            # Special case: Genotype containing query sequence gets additional length
-            query_bonus = 0.5 if contains_query else 0.0
-
-            # Calculate length based on sequence count
-            # More sequences = longer horizontal line
-            if sequence_count <= 1:
-                # Single sequence
-                length_multiplier = 1.0
-            elif sequence_count <= 3:
-                # 2-3 sequences
-                length_multiplier = 1.6
-            elif sequence_count <= 5:
-                # 4-5 sequences
-                length_multiplier = 2.3
-            elif sequence_count <= 8:
-                # 6-8 sequences
-                length_multiplier = 6.0
-            else:
-                # More than 8 sequences
-                length_multiplier = 6.0
-
-            # Calculate final length
-            calculated_length = base_length * length_multiplier + query_bonus
-
-            return calculated_length
-
-        except Exception as e:
-            print(f"Error determining genotype horizontal line length: {e}")
-            return self.base_horizontal_length
-
-    def _calculate_genotype_positions(self, special_genotypes: List, base_y: float) -> List[float]:
-        """Calculate equal positions for genotypes"""
-        try:
-            genotype_count = len(special_genotypes)
-            if genotype_count <= 1:
-                return [base_y]
-
-            # Equal spacing for genotypes
-            spacing = 1.0  # Fixed spacing between genotypes
-            start_y = base_y - (spacing * (genotype_count - 1)) / 2
-
-            positions = []
-            for i in range(genotype_count):
-                positions.append(start_y + i * spacing)
-
-            return positions
-
-        except Exception as e:
-            print(f"Error calculating genotype positions: {e}")
-            return [base_y] * len(special_genotypes)
-
-    def _add_representative_sequences(self, normalized_ml_node: Dict, representative_sequences: List[Dict], base_y: float, parent_x: float):
-        """Add representative sequences directly to normalized ML node"""
-        try:
-            if not representative_sequences:
-                return
-
-            # Calculate horizontal line length for representative sequences
-            # Representative sequences get a standard length (not similarity-based since they're not matched)
-            has_vertical = len(representative_sequences) > 1
-            horizontal_length = self._determine_horizontal_line_length('representative', has_vertical)
-            x_pos = parent_x + horizontal_length
-
-            if len(representative_sequences) == 1:
-                seq = representative_sequences[0]
-                normalized_ml_node['children'][f"{seq['id']}_rep"] = {
-                    'name': f"{seq['id']} (Rep)",
-                    'type': 'representative_sequence',
-                    'data': seq,
-                    'x': x_pos,
-                    'y': base_y,
-                    'has_vertical_attachment': False,
-                    'horizontal_line_length': horizontal_length
-                }
-            else:
-                # Equal spacing for multiple representative sequences
-                positions = self._calculate_sequence_positions(representative_sequences, base_y)
-
-                for idx, seq in enumerate(representative_sequences):
-                    normalized_ml_node['children'][f"{seq['id']}_rep"] = {
-                        'name': f"{seq['id']} (Rep)",
-                        'type': 'representative_sequence',
-                        'data': seq,
-                        'x': x_pos,
-                        'y': positions[idx],
-                        'has_vertical_attachment': False,
-                        'horizontal_line_length': horizontal_length
-                    }
-
-        except Exception as e:
-            print(f"Error adding representative sequences: {e}")
-
-    def _add_sequences_horizontal(self, genotype_node: Dict, sequences: List[Dict], base_y: float, parent_x: float):
-        """Add sequences horizontally with similarity-based line lengths"""
-        try:
-            # Define the query line length as the reference (100%)
-            query_line_length = 3.0  # Base length for query sequence (100%)
-
-            # Separate query and matched sequences
-            query_sequences = [seq for seq in sequences if seq['is_query']]
-            matched_sequences = [seq for seq in sequences if seq['is_matched'] and not seq['is_query']]
-
-            all_special_sequences = query_sequences + matched_sequences
-
-            if len(all_special_sequences) == 1:
-                # Single sequence - direct line with similarity-based length
-                sequence = all_special_sequences[0]
-                line_length = self._calculate_similarity_based_line_length(sequence, query_line_length)
-                x_pos = parent_x + line_length
-
-                genotype_node['children'][sequence['id']] = {
-                    'name': f"{sequence['id']}{' (' + str(sequence['similarity']) + '%)' if sequence['is_matched'] else ''}",
-                    'type': 'sequence',
-                    'data': sequence,
-                    'x': x_pos,
-                    'y': base_y,
-                    'has_vertical_attachment': False,
-                    'similarity_line_length': line_length
-                }
-            else:
-                # Multiple sequences - equal vertical distribution with similarity-based horizontal lengths
-                sequence_positions = self._calculate_sequence_positions(all_special_sequences, base_y)
-
-                for seq_idx, sequence in enumerate(all_special_sequences):
-                    line_length = self._calculate_similarity_based_line_length(sequence, query_line_length)
-                    x_pos = parent_x + line_length
-
-                    genotype_node['children'][sequence['id']] = {
-                        'name': f"{sequence['id']}{' (' + str(sequence['similarity']) + '%)' if sequence['is_matched'] else ''}",
-                        'type': 'sequence',
-                        'data': sequence,
-                        'x': x_pos,
-                        'y': sequence_positions[seq_idx],
-                        'has_vertical_attachment': False,
-                        'similarity_line_length': line_length
-                    }
-        except Exception as e:
-            print(f"Error adding sequences horizontally: {e}")
-
-    def _calculate_similarity_based_line_length(self, sequence: Dict, query_line_length: float) -> float:
-        """Calculate line length based on similarity percentage relative to query"""
-        try:
-            if sequence['is_query']:
-                # Query sequence gets 100% length
-                return query_line_length
-            elif sequence['is_matched']:
-                # Matched sequences get length proportional to their similarity
-                similarity = sequence['similarity']
-                # Convert similarity percentage to proportional length
-                proportional_length = (similarity / 100.0) * query_line_length
-                # Ensure minimum length for visibility
-                min_length = query_line_length * 0.2  # Minimum 20% of query length
-                return max(proportional_length, min_length)
-            else:
-                # Other sequences get a standard length (50% of query)
-                return query_line_length * 0.5
-        except Exception as e:
-            print(f"Error calculating similarity-based line length: {e}")
-            return query_line_length * 0.5
-
-
-    def _calculate_sequence_positions(self, sequences: List[Dict], base_y: float) -> List[float]:
-        """Calculate equal positions for sequences"""
-        try:
-            seq_count = len(sequences)
-            if seq_count <= 1:
-                return [base_y]
-
-            # Equal spacing for sequences
-            spacing = 0.8  # Fixed spacing between sequences
-            start_y = base_y - (spacing * (seq_count - 1)) / 2
-
-            positions = []
-            for i in range(seq_count):
-                positions.append(start_y + i * spacing)
-
-            return positions
-
-        except Exception as e:
-            print(f"Error calculating sequence positions: {e}")
-            return [base_y] * len(sequences)
-
-    def _determine_horizontal_line_length(self, node_type: str, has_vertical: bool, contains_query: bool = False) -> float:
-        """Determine horizontal line length based on node type and connections"""
-        try:
-            base_length = self.base_horizontal_length
-
-            # Special case: ML group containing query sequence gets much longer line
-            if contains_query and node_type == 'normalized_ml_group':
-                return base_length * 2.5  # Much longer for query ML group
-
-            # If this node has a vertical line attachment (connects to multiple children)
-            if has_vertical:
-                # Find the current longest horizontal line with vertical
-                current_max = base_length
-                for tracked_length in self.horizontal_line_tracker:
-                    if tracked_length > current_max:
-                        current_max = tracked_length
-
-                # Make this line incrementally longer
-                new_length = current_max + 0.3
-                self.horizontal_line_tracker.append(new_length)
-                return new_length
-            else:
-                # Direct connection (no vertical), use base length
-                return base_length
-
-        except Exception as e:
-            print(f"Error determining horizontal line length: {e}")
-            return self.base_horizontal_length
-
-    def _identify_query_ml_group(self, normalized_ml_groups: Dict):
-        """Identify which ML group contains the query sequence"""
-        try:
-            for base_ml, ml_data in normalized_ml_groups.items():
-                if ml_data['has_special_sequences']:
-                    for full_ml_name, genotypes in ml_data['full_ml_groups'].items():
-                        for genotype, sequences in genotypes.items():
-                            if any(seq['is_query'] for seq in sequences):
-                                self.query_ml_group = base_ml
-                                return
-        except Exception as e:
-            print(f"Error identifying query ML group: {e}")
-
-    def _identify_query_ml_group(self, normalized_ml_groups: Dict):
-        """Identify which ML group contains the query sequence"""
-        try:
-            for base_ml, ml_data in normalized_ml_groups.items():
-                if ml_data['has_special_sequences']:
-                    for full_ml_name, genotypes in ml_data['full_ml_groups'].items():
-                        for genotype, sequences in genotypes.items():
-                            if any(seq['is_query'] for seq in sequences):
-                                self.query_ml_group = base_ml
-                                return
-        except Exception as e:
-            print(f"Error identifying query ML group: {e}")
-
-    def _calculate_sequence_x_position_horizontal(self, sequence: Dict, max_similarity: float) -> float:
-        """Calculate X position based on similarity percentage for horizontal layout"""
-        # This function is now replaced by _calculate_similarity_based_line_length
-        # Keeping for backward compatibility, but the new approach is used in _add_sequences_horizontal
-
-        base_x = 0  # Relative to parent genotype node
-        query_line_length = 3.0  # Reference length for query (100%)
-
-        if sequence['is_query']:
-            return base_x + query_line_length  # 100% length for query
-        elif sequence['is_matched']:
-            # Line length varies based on similarity percentage
-            similarity = sequence['similarity']
-            proportional_length = (similarity / 100.0) * query_line_length
-            min_length = query_line_length * 0.2  # Minimum 20% of query length
-            return base_x + max(proportional_length, min_length)
-        else:
-            return base_x + (query_line_length * 0.5)  # 50% length for other sequences
-
-
-    def create_interactive_tree(self, matched_ids: List[str], actual_percentage: float):
-        try:
-            print("🎨 Creating horizontal interactive tree visualization...")
-
-            # Prepare data for plotting
-            edge_x = []
-            edge_y = []
-            node_x = []
-            node_y = []
-            node_colors = []
-            node_text = []
-            node_hover = []
-            node_sizes = []
-
-            # Updated color scheme for new node types
-            colors = {
-                'root': '#FF0000',                    # Red for root
-                'normalized_ml_group': '#FFB6C1',     # Light pink for normalized ML groups
-                'full_ml_group': '#FF69B4',           # Hot pink for full ML groups
-                'genotype': '#FFD700',                # Gold for genotypes
-                'representative_sequence': '#FFA500', # Orange for representative sequences
-                'query_sequence': '#4B0082',          # Dark purple for query
-                'matched_sequence': '#6A5ACD',        # Slate blue for matched
-                'other_sequence': '#87CEEB'           # Sky blue for others
-            }
-
-            def add_horizontal_edges(parent_x, parent_y, children_dict):
-                """Add horizontal connecting lines with proper vertical line sizing"""
-                if not children_dict:
-                    return
-
-                children_list = list(children_dict.values())
-
-                if len(children_list) == 1:
-                    # Single child - direct horizontal line
-                    child = children_list[0]
-                    edge_x.extend([parent_x, child['x'], None])
-                    edge_y.extend([parent_y, child['y'], None])
-                else:
-                    # Multiple children - horizontal line with vertical distribution
-                    # Calculate the intermediate x position (where vertical line will be)
-                    child_x_positions = [child['x'] for child in children_list]
-                    min_child_x = min(child_x_positions)
-                    intermediate_x = parent_x + (min_child_x - parent_x) * 0.8  # 80% of the way to nearest child
-
-                    # Horizontal line to intermediate point
-                    edge_x.extend([parent_x, intermediate_x, None])
-                    edge_y.extend([parent_y, parent_y, None])
-
-                    # Calculate vertical line range to fit exactly all children
-                    child_y_positions = [child['y'] for child in children_list]
-                    min_y, max_y = min(child_y_positions), max(child_y_positions)
-
-                    # Vertical line sized exactly to fit all children
-                    edge_x.extend([intermediate_x, intermediate_x, None])
-                    edge_y.extend([min_y, max_y, None])
-
-                    # Horizontal lines from vertical line to each child
-                    for child in children_list:
-                        edge_x.extend([intermediate_x, child['x'], None])
-                        edge_y.extend([child['y'], child['y'], None])
-
-            def get_node_color_and_size(node):
-                """Determine node color and size based on type and content"""
-                if node['type'] == 'sequence':
-                    if node['data']['is_query']:
-                        return colors['query_sequence'], 10  # Reduced size for compactness
-                    elif node['data']['is_matched']:
-                        return colors['matched_sequence'], 8
-                    else:
-                        return colors['other_sequence'], 6
-                elif node['type'] == 'representative_sequence':
-                    return colors['representative_sequence'], 7
-                elif node['type'] == 'normalized_ml_group':
-                    # Larger size if it has special sequences
-                    size = 9 if node.get('has_special_sequences', False) else 7
-                    return colors['normalized_ml_group'], size
-                elif node['type'] == 'full_ml_group':
-                    return colors['full_ml_group'], 8
-                elif node['type'] == 'genotype':
-                    return colors['genotype'], 7
-                else:
-                    return colors.get(node['type'], '#000000'), 7
-
-            def create_node_text(node):
-                """Create appropriate text label for each node type"""
-                if node['type'] == 'sequence':
-                    if node['data']['is_matched'] and not node['data']['is_query']:
-                        return f"{node['name']}"
-                    else:
-                        return node['name']
-                elif node['type'] == 'representative_sequence':
-                    return node['name']
-                elif node['type'] == 'normalized_ml_group':
-                    # Add indicator if it has special sequences
-                    suffix = " *" if node.get('has_special_sequences', False) else ""
-                    return f"{node['name']}{suffix}"
-                else:
-                    return node['name']
-
-            def create_hover_text(node):
-                """Create detailed hover text for each node type"""
-                if node['type'] == 'sequence':
-                    data = node['data']['data']
-                    hover_text = (
-                        f"<b>{node['name']}</b><br>"
-                        f"Type: {'Query Sequence' if node['data']['is_query'] else 'Matched Sequence' if node['data']['is_matched'] else 'Other Sequence'}<br>"
-                        f"ML Group: {data.get('ML', 'N/A')}<br>"
-                        f"Genotype: {data.get('Genotype', 'N/A')}<br>"
-                        f"Host: {data.get('Host', 'N/A')}<br>"
-                        f"Country: {data.get('Country', 'N/A')}<br>"
-                        f"Isolate: {data.get('Isolate', 'N/A')}<br>"
-                        f"Year: {data.get('Year', 'N/A')}"
-                    )
-                    if node['data']['is_matched']:
-                        hover_text += f"<br><b>Similarity: {node['data']['similarity']}%</b>"
-                elif node['type'] == 'representative_sequence':
-                    data = node['data']['data']
-                    hover_text = (
-                        f"<b>{node['name']}</b><br>"
-                        f"Type: Representative Sequence<br>"
-                        f"ML Group: {data.get('ML', 'N/A')}<br>"
-                        f"Genotype: {data.get('Genotype', 'N/A')}<br>"
-                        f"Host: {data.get('Host', 'N/A')}<br>"
-                        f"Country: {data.get('Country', 'N/A')}"
-                    )
-                elif node['type'] == 'normalized_ml_group':
-                    hover_text = f"<b>{node['name']}</b><br>Type: Normalized ML Group"
-                    if node.get('has_special_sequences', False):
-                        hover_text += "<br>Contains query/matched sequences"
-                    else:
-                        hover_text += "<br>Representative sequences only"
-                elif node['type'] == 'full_ml_group':
-                    hover_text = f"<b>{node['name']}</b><br>Type: Full ML Group"
-                    if 'sequences_count' in node:
-                        hover_text += f"<br>Total Sequences: {node['sequences_count']}"
-                elif node['type'] == 'genotype':
-                    hover_text = f"<b>{node['name']}</b><br>Type: Genotype"
-                    if 'sequences' in node:
-                        special_count = sum(1 for seq in node['sequences'] if seq['is_query'] or seq['is_matched'])
-                        hover_text += f"<br>Special Sequences: {special_count}/{len(node['sequences'])}"
-                else:
-                    hover_text = f"<b>{node['name']}</b><br>Type: {node['type'].replace('_', ' ').title()}"
-
-                return hover_text
-
-            def add_node_and_edges(node, parent_x=None, parent_y=None):
-                """Recursively add nodes and edges to the plot with equal spacing structure."""
-                x, y = node['x'], node['y']
-                node_x.append(x)
-                node_y.append(y)
-
-                # Get node color and size
-                color, size = get_node_color_and_size(node)
-                node_colors.append(color)
-                node_sizes.append(size)
-
-                # Create node text and hover
-                node_text.append(create_node_text(node))
-                node_hover.append(create_hover_text(node))
-
-                # Process children with equal spacing structure
-                if 'children' in node and node['children']:
-                    add_horizontal_edges(x, y, node['children'])
-                    for child in node['children'].values():
-                        add_node_and_edges(child, x, y)
-
-            # Build the plot data starting from root
-            root_node = self.tree_structure['root']
-            add_node_and_edges(root_node)
-
-            # Add horizontal edges for root level
-            if root_node['children']:
-                add_horizontal_edges(root_node['x'], root_node['y'], root_node['children'])
-
-            # Create the figure
-            fig = go.Figure()
-
-            # Add edges
-            fig.add_trace(go.Scatter(
-                x=edge_x, y=edge_y,
-                mode='lines',
-                line=dict(width=1, color='gray', dash='solid'),  # Thinner lines for compactness
-                hoverinfo='none',
-                showlegend=False,
-                name='Edges'
-            ))
-
-            # Add nodes
-            fig.add_trace(go.Scatter(
-                x=node_x, y=node_y,
-                mode='markers+text',
-                marker=dict(
-                    size=node_sizes,
-                    color=node_colors,
-                    line=dict(width=1, color='black'),  # Thinner borders
-                    opacity=0.85
-                ),
-                text=node_text,
-                textposition="middle right",
-                textfont=dict(size=9, color="black"),  # Smaller font for compactness
-                hoverinfo='text',
-                hovertext=node_hover,
-                showlegend=False,
-                name='Nodes'
-            ))
-
-            # Calculate proper layout dimensions to ensure everything fits
-            if node_x and node_y:
-                # Get the actual data bounds
-                min_x, max_x = min(node_x), max(node_x)
-                min_y, max_y = min(node_y), max(node_y)
-
-                # Calculate ranges
-                x_range = max_x - min_x
-                y_range = max_y - min_y
-
-                # Add padding to ensure nothing is cut off (20% padding on each side)
-                x_padding = x_range * 0.2 if x_range > 0 else 1
-                y_padding = y_range * 0.2 if y_range > 0 else 1
-
-                # Set axis ranges with padding
-                x_axis_range = [min_x - x_padding, max_x + x_padding]
-                y_axis_range = [min_y - y_padding, max_y + y_padding]
-
-                # Compact but sufficient sizing
-                width = min(1400, max(800, int(x_range * 80 + 400)))  # Cap max width
-                height = min(900, max(500, int(y_range * 40 + 300)))  # Cap max height
-            else:
-                width, height = 800, 500
-                x_axis_range = None
-                y_axis_range = None
-
-            # Update layout for compact horizontal tree with proper bounds
-            fig.update_layout(
-                title=dict(
-                    text=f"Compact Horizontal Phylogenetic Tree (ML-Based)<br>"
-                        f"Query: {self.query_id} | Similarity: {actual_percentage}% | "
-                        f"Matched: {len(matched_ids)}",
-                    x=0.5,
-                    font=dict(size=12)  # Smaller title for compactness
-                ),
-                xaxis=dict(
-                    showgrid=False,
-                    gridcolor='lightgray',
-                    gridwidth=0.3,  # Very thin grid lines
-                    zeroline=False,
-                    showticklabels=False,
-                    range=x_axis_range,  # Set explicit range to prevent cutoff
-                    fixedrange=False,    # Allow zooming if needed
-                    automargin=True      # Automatically adjust margins
-                ),
-                yaxis=dict(
-                    showgrid=False,
-                    gridcolor='lightgray',
-                    gridwidth=0.3,  # Very thin grid lines
-                    zeroline=False,
-                    showticklabels=False,
-                    range=y_axis_range,  # Set explicit range to prevent cutoff
-                    fixedrange=False,    # Allow zooming if needed
-                    automargin=True      # Automatically adjust margins
-                ),
-                plot_bgcolor="white",
-                paper_bgcolor="white",
-                hovermode="closest",
-                width=width,
-                height=height,
-                margin=dict(l=20, r=100, t=40, b=10),  # Adequate margins, extra right margin for text
-                autosize=False,  # Don't auto-resize
-                showlegend=True,
-                legend=dict(
-                    x=1.02,  # Position legend outside plot area
-                    y=1,
-                    xanchor='left',
-                    yanchor='top',
-                    bgcolor='rgba(255,255,255,0.8)',
-                    bordercolor='gray',
-                    borderwidth=1,
-                    font=dict(size=10)  # Smaller legend font
-                )
-            )
-
-            # Add comprehensive legend with smaller markers
-            legend_elements = [
-                dict(name="Root", marker=dict(color=colors['root'], size=8)),
-                dict(name="Normalized ML Groups", marker=dict(color=colors['normalized_ml_group'], size=8)),
-                dict(name="Full ML Groups", marker=dict(color=colors['full_ml_group'], size=8)),
-                dict(name="Genotypes", marker=dict(color=colors['genotype'], size=8)),
-                dict(name="Query Sequence", marker=dict(color=colors['query_sequence'], size=10)),
-                dict(name="Similar Sequences", marker=dict(color=colors['matched_sequence'], size=9)),
-                dict(name="Representative Sequences", marker=dict(color=colors['representative_sequence'], size=8)),
-                dict(name="Other Sequences", marker=dict(color=colors['other_sequence'], size=7))
-            ]
-
-            for i, element in enumerate(legend_elements):
-                fig.add_trace(go.Scatter(
-                    x=[None], y=[None],
-                    mode='markers',
-                    marker=element['marker'],
-                    name=element['name'],
-                    showlegend=True
-                ))
-
-
-            # Configure modebar for better user experience
-            config = {
-                'displayModeBar': True,
-                'displaylogo': False,
-                'modeBarButtonsToRemove': ['select2d', 'lasso2d'],
-                'toImageButtonOptions': {
-                    'format': 'png',
-                    'filename': 'phylogenetic_tree',
-                    'height': height,
-                    'width': width,
-                    'scale': 2
-                }
-            }
-
-            # Save outputs
-            try:
-                fig.write_html("phylogenetic_tree_normalized_horizontal.html", config=config)
-                print("✓ Compact horizontal interactive tree saved as 'phylogenetic_tree_normalized_horizontal.html'")
-            except Exception as e:
-                print(f"Warning: Could not save HTML file: {e}")
-
-            # Display the figure with config
-            try:
-                fig.show(config=config)
-            except Exception as e:
-                print(f"Warning: Could not display figure: {e}")
-
-            return fig
-
-        except Exception as e:
-            print(f"Error creating compact horizontal interactive tree: {e}")
-            return None
-
-
-    def create_sequence_alignment(self, sequence_ids: List[str]) -> Optional[MultipleSeqAlignment]:
-
-        try:
-            print("🧬 Creating multiple sequence alignment...")
-
-            # Get sequences
-            sequences = []
-            for seq_id in sequence_ids:
-                try:
-                    row = self.data[self.data['Accession Number'] == seq_id]
-                    if not row.empty:
-                        f_gene = str(row.iloc[0]['F-gene'])
-                        # Clean sequence (remove non-nucleotide characters)
-                        clean_seq = re.sub(r'[^ATGCN-]', '', f_gene.upper())
-                        if len(clean_seq) > 10:  # Minimum sequence length
-                            seq_record = SeqRecord(Seq(clean_seq), id=seq_id, description="")
-                            sequences.append(seq_record)
-                except Exception as e:
-                    print(f"Warning: Skipping sequence {seq_id}: {e}")
-                    continue
-
-            if len(sequences) < 2:
-                print("❌ Need at least 2 valid sequences for alignment")
-                return None
-
-            # Simple alignment (you might want to use MUSCLE or CLUSTAL for better results)
-            aligned_sequences = self._simple_alignment(sequences)
-
-            print(f"✓ Alignment created with {len(aligned_sequences)} sequences")
-            return MultipleSeqAlignment(aligned_sequences)
-
-        except Exception as e:
-            print(f"Error creating alignment: {e}")
-            return None
-
-    def _simple_alignment(self, sequences: List[SeqRecord]) -> List[SeqRecord]:
-
-        try:
-            # Find maximum length
-            max_length = max(len(seq.seq) for seq in sequences)
-
-            # Cap maximum length to prevent memory issues
-            if max_length > 10000:
-                max_length = 10000
-                print(f"Warning: Sequences truncated to {max_length} bp")
-
-            # Pad sequences to same length
-            aligned_sequences = []
-            for seq in sequences:
-                seq_str = str(seq.seq)[:max_length]  # Truncate if too long
-
-                if len(seq_str) < max_length:
-                    # Pad with gaps at the end
-                    padded_seq = seq_str + '-' * (max_length - len(seq_str))
-                else:
-                    padded_seq = seq_str
-
-                aligned_sequences.append(SeqRecord(Seq(padded_seq), id=seq.id, description=seq.description))
-
-            return aligned_sequences
-        except Exception as e:
-            print(f"Error in simple alignment: {e}")
-            return sequences  # Return original sequences as fallback
-
-    def calculate_ml_distances(self, alignment: MultipleSeqAlignment) -> np.ndarray:
-
-        try:
-            print("📊 Calculating ML distances...")
-
-            # Convert alignment to numeric matrix
-            seq_matrix = self._alignment_to_matrix(alignment)
-            n_sequences = len(alignment)
-
-            if n_sequences == 0:
-                return np.array([])
-
-            # Initialize distance matrix
-            distance_matrix = np.zeros((n_sequences, n_sequences))
-
-            # Calculate pairwise ML distances
-            for i in range(n_sequences):
-                for j in range(i + 1, n_sequences):
-                    try:
-                        ml_distance = self._calculate_ml_distance_pair(seq_matrix[i], seq_matrix[j])
-                        distance_matrix[i][j] = ml_distance
-                        distance_matrix[j][i] = ml_distance
-                    except Exception as e:
-                        print(f"Warning: Error calculating distance between sequences {i} and {j}: {e}")
-                        # Use maximum distance as fallback
-                        distance_matrix[i][j] = 1.0
-                        distance_matrix[j][i] = 1.0
-
-            print("✓ ML distances calculated")
-            return distance_matrix
-
-        except Exception as e:
-            print(f"Error calculating ML distances: {e}")
-            return np.array([])
-
-    def _alignment_to_matrix(self, alignment: MultipleSeqAlignment) -> np.ndarray:
-
-        try:
-            # Nucleotide to number mapping
-            nucleotide_map = {'A': 0, 'T': 1, 'G': 2, 'C': 3, 'N': 4, '-': 5}
-
-            matrix = []
-            for record in alignment:
-                sequence = str(record.seq).upper()
-                numeric_seq = [nucleotide_map.get(nuc, 4) for nuc in sequence]
-                matrix.append(numeric_seq)
-
-            return np.array(matrix)
-        except Exception as e:
-            print(f"Error converting alignment to matrix: {e}")
-            return np.array([])
-
-    def _calculate_ml_distance_pair(self, seq1: np.ndarray, seq2: np.ndarray) -> float:
-
-        try:
-            if len(seq1) == 0 or len(seq2) == 0:
-                return 1.0
-
-            # Count differences (excluding gaps and N's)
-            valid_positions = (seq1 < 4) & (seq2 < 4)  # Exclude N's and gaps
-
-            if np.sum(valid_positions) == 0:
-                return 1.0  # Maximum distance if no valid comparisons
-
-            differences = np.sum(seq1[valid_positions] != seq2[valid_positions])
-            total_valid = np.sum(valid_positions)
-
-            if total_valid == 0:
-                return 1.0
-
-            # Calculate proportion of differences
-            p = differences / total_valid
-
-            # Jukes-Cantor correction
-            if p >= 0.75:
-                return 1.0  # Maximum distance
-
-            # JC distance formula: -3/4 * ln(1 - 4p/3)
-            try:
-                jc_distance = -0.75 * np.log(1 - (4 * p / 3))
-                return min(max(jc_distance, 0.0), 1.0)  # Clamp between 0 and 1
-            except (ValueError, RuntimeWarning):
-                return 1.0  # Return maximum distance if log calculation fails
-
-        except Exception as e:
-            return 1.0  # Return maximum distance on error
-
-    def construct_ml_tree(self, alignment: MultipleSeqAlignment) -> Optional[BaseTree.Tree]:
-
-        try:
-            print("🌳 Constructing Maximum Likelihood tree...")
-
-            # Calculate ML distance matrix
-            distance_matrix = self.calculate_ml_distances(alignment)
-
-            if distance_matrix.size == 0:
-                return None
-
-            # Create sequence names list
-            sequence_names = [record.id for record in alignment]
-
-            # Build tree using neighbor-joining on ML distances
-            tree = self._build_nj_tree_from_distances(distance_matrix, sequence_names)
-
-            # Optimize branch lengths using ML (with recursion protection)
-            if tree:
-                tree = self._optimize_branch_lengths_ml_safe(tree, alignment)
-
-            print("✓ ML tree constructed successfully")
-            return tree
-
-        except Exception as e:
-            print(f"Error constructing ML tree: {e}")
-            return None
-
-    def _build_nj_tree_from_distances(self, distance_matrix: np.ndarray, sequence_names: List[str]) -> Optional[BaseTree.Tree]:
-
-        try:
-            from Bio.Phylo.TreeConstruction import DistanceMatrix, DistanceTreeConstructor
-
-            # Validate inputs
-            if distance_matrix.shape[0] != len(sequence_names):
-                print("Error: Distance matrix size doesn't match sequence names")
-                return None
-
-            # Convert numpy array to Bio.Phylo distance matrix format
-            matrix_data = []
-            for i in range(len(sequence_names)):
-                row = []
-                for j in range(i + 1):
-                    if i == j:
-                        row.append(0.0)
-                    else:
-                        # Ensure distance is valid
-                        dist = float(distance_matrix[i][j])
-                        if np.isnan(dist) or np.isinf(dist):
-                            dist = 1.0
-                        row.append(max(0.0, dist))  # Ensure non-negative
-                matrix_data.append(row)
-
-            # Create DistanceMatrix object
-            dm = DistanceMatrix(names=sequence_names, matrix=matrix_data)
-
-            # Build tree using Neighbor-Joining
-            constructor = DistanceTreeConstructor()
-            tree = constructor.nj(dm)
-
-            # Validate tree structure
-            if tree and self._validate_tree_structure(tree):
-                return tree
-            else:
-                print("Warning: Tree structure validation failed")
-                return tree  # Return anyway, might still be usable
-
-        except Exception as e:
-            print(f"Error building NJ tree: {e}")
-            return None
-
-    def _validate_tree_structure(self, tree: BaseTree.Tree, max_depth: int = 100) -> bool:
-
-        try:
-            visited = set()
-
-            def check_node(node, depth=0):
-                if depth > max_depth:
-                    return False
-
-                # Check for circular references
-                node_id = id(node)
-                if node_id in visited:
-                    return False
-                visited.add(node_id)
-
-                # Check children
-                for child in getattr(node, 'clades', []):
-                    if not check_node(child, depth + 1):
-                        return False
-
-                return True
-
-            return check_node(tree.root if hasattr(tree, 'root') else tree)
-        except Exception:
-            return False
-
-    def _optimize_branch_lengths_ml_safe(self, tree: BaseTree.Tree, alignment: MultipleSeqAlignment) -> BaseTree.Tree:
-
-        try:
-            print("🔧 Optimizing branch lengths with ML...")
-
-            # Set recursion limit temporarily
-            old_limit = sys.getrecursionlimit()
-            sys.setrecursionlimit(1000)
-
-            try:
-                # Convert alignment to matrix
-                seq_matrix = self._alignment_to_matrix(alignment)
-
-                if seq_matrix.size == 0:
-                    print("Warning: Empty sequence matrix, skipping optimization")
-                    return tree
-
-                # Get all internal and external nodes with depth tracking
-                all_clades = self._get_clades_safe(tree)
-
-                # Simple branch length optimization
-                for clade in all_clades:
-                    if hasattr(clade, 'branch_length') and clade.branch_length is not None:
-                        try:
-                            # Calculate optimal branch length based on likelihood
-                            optimal_length = self._calculate_optimal_branch_length_safe(clade, seq_matrix)
-                            clade.branch_length = max(optimal_length, 0.001)  # Minimum branch length
-                        except Exception as e:
-                            print(f"Warning: Failed to optimize branch for clade: {e}")
-                            # Keep original branch length
-                            pass
-
-                print("✓ Branch lengths optimized")
-
-            finally:
-                # Restore original recursion limit
-                sys.setrecursionlimit(old_limit)
-
-            return tree
-
-        except Exception as e:
-            print(f"Warning: Branch length optimization failed: {e}")
-            return tree
-
-    def _get_clades_safe(self, tree: BaseTree.Tree, max_depth: int = 50) -> List:
-
-        clades = []
-        visited = set()
-
-        def traverse_node(node, depth=0):
-            if depth > max_depth or id(node) in visited:
-                return
-
-            visited.add(id(node))
-            clades.append(node)
-
-            # Traverse children safely
-            try:
-                children = getattr(node, 'clades', [])
-                for child in children:
-                    traverse_node(child, depth + 1)
-            except Exception:
-                pass  # Skip problematic nodes
-
-        try:
-            root = tree.root if hasattr(tree, 'root') else tree
-            traverse_node(root)
-        except Exception as e:
-            print(f"Warning: Tree traversal error: {e}")
-
-        return clades
-
-    def _calculate_optimal_branch_length_safe(self, clade, seq_matrix: np.ndarray) -> float:
-
-        try:
-            # Simplified ML branch length estimation
-            if not hasattr(clade, 'branch_length') or clade.branch_length is None:
-                return 0.1  # Default branch length
-
-            current_length = float(clade.branch_length)
-
-            # Validate current length
-            if np.isnan(current_length) or np.isinf(current_length) or current_length <= 0:
-                return 0.1
-
-            # Simple optimization based on sequence characteristics
-            if hasattr(clade, 'name') and clade.name:
-                # For terminal nodes
-                return min(max(current_length * 0.9, 0.001), 1.0)
-            else:
-                # For internal nodes
-                return min(max(current_length * 1.1, 0.001), 1.0)
-
-        except Exception:
-            return 0.1  # Safe default
-
-    def calculate_ml_likelihood_safe(self, tree: BaseTree.Tree, alignment: MultipleSeqAlignment) -> float:
-
-        try:
-            print("📈 Calculating tree likelihood...")
-
-            seq_matrix = self._alignment_to_matrix(alignment)
-
-            if seq_matrix.size == 0:
-                return -np.inf
-
-            # Simplified likelihood calculation using Jukes-Cantor model
-            total_log_likelihood = 0.0
-
-            # For each site in the alignment (sample subset to avoid memory issues)
-            n_sites = min(seq_matrix.shape[1], 1000)  # Limit sites for performance
-
-            for site in range(0, n_sites, max(1, n_sites // 100)):  # Sample sites
-                try:
-                    site_pattern = seq_matrix[:, site]
-
-                    # Skip sites with gaps or N's
-                    valid_positions = site_pattern < 4
-                    if np.sum(valid_positions) < 2:
-                        continue
-
-                    # Calculate likelihood for this site pattern
-                    site_likelihood = self._calculate_site_likelihood_safe(tree, site_pattern)
-
-                    if site_likelihood > 0:
-                        total_log_likelihood += np.log(site_likelihood)
-
-                except Exception as e:
-                    print(f"Warning: Error processing site {site}: {e}")
-                    continue
-
-            print(f"✓ Tree likelihood calculated: {total_log_likelihood:.2f}")
-            return total_log_likelihood
-
-        except Exception as e:
-            print(f"Error calculating likelihood: {e}")
-            return -np.inf
-
-    def _calculate_site_likelihood_safe(self, tree: BaseTree.Tree, site_pattern: np.ndarray) -> float:
-
-        try:
-            # Count nucleotide frequencies at this site
-            valid_nucs = site_pattern[site_pattern < 4]
-
-            if len(valid_nucs) == 0:
-                return 1.0
-
-            # Simple likelihood based on nucleotide diversity
-            unique_nucs = len(np.unique(valid_nucs))
-            total_nucs = len(valid_nucs)
-
-            # Higher diversity = lower likelihood of simple evolution
-            diversity_factor = unique_nucs / 4.0  # Normalize by 4 nucleotides
-
-            # Simple likelihood model
-            likelihood = np.exp(-diversity_factor * total_nucs * 0.1)
-
-            return max(likelihood, 1e-10)  # Avoid zero likelihood
-
-        except Exception:
-            return 1e-10  # Safe fallback
-
-    def perform_ml_analysis_safe(self, matched_ids: List[str]) -> Dict:
-
-        try:
-            print("\n🧬 PERFORMING MAXIMUM LIKELIHOOD ANALYSIS")
-            print("="*50)
-
-            # Include query sequence in analysis
-            all_sequences = [self.query_id] + [seq_id for seq_id in matched_ids if seq_id != self.query_id]
-
-            # Limit number of sequences to prevent memory issues
-            if len(all_sequences) > 20:
-                print(f"Warning: Limiting analysis to 20 sequences (had {len(all_sequences)})")
-                all_sequences = all_sequences[:20]
-
-            if len(all_sequences) < 3:
-                print("❌ Need at least 3 sequences for ML analysis")
-                return {}
-
-            # Step 1: Create multiple sequence alignment
-            alignment = self.create_sequence_alignment(all_sequences)
-            if not alignment:
-                return {}
-
-            # Step 2: Calculate ML distances
-            distance_matrix = self.calculate_ml_distances(alignment)
-            if distance_matrix.size == 0:
-                return {}
-
-            # Step 3: Construct ML tree
-            ml_tree = self.construct_ml_tree(alignment)
-            if not ml_tree:
-                return {}
-
-            # Step 4: Calculate tree likelihood (safely)
-            log_likelihood = self.calculate_ml_likelihood_safe(ml_tree, alignment)
-
-            # Step 5: Prepare results
-            ml_results = {
-                'tree': ml_tree,
-                'alignment': alignment,
-                'distance_matrix': distance_matrix,
-                'log_likelihood': log_likelihood,
-                'sequence_count': len(all_sequences),
-                'alignment_length': len(alignment[0]) if alignment else 0
-            }
-
-            print(f"✅ ML analysis completed successfully")
-            print(f"   Sequences analyzed: {len(all_sequences)}")
-            print(f"   Alignment length: {ml_results['alignment_length']}")
-            print(f"   Log-likelihood: {log_likelihood:.2f}")
-
-            return ml_results
-
-        except Exception as e:
-            print(f"❌ ML analysis failed: {e}")
-            import traceback
-            traceback.print_exc()
-            return {}
-
-    def build_tree_structure_with_ml_safe(self, matched_ids: List[str]) -> Dict:
-
-        try:
-            print("🌳 Building ML-enhanced tree structure...")
-
-            # Perform ML analysis first
-            ml_results = self.perform_ml_analysis_safe(matched_ids)
-
-            # Build the original hierarchical structure
-            tree_structure = self.build_tree_structure(matched_ids)
-
-            # Enhance with ML information
-            if ml_results and 'tree' in ml_results:
-                tree_structure['ml_analysis'] = {
-                    'log_likelihood': ml_results['log_likelihood'],
-                    'sequence_count': ml_results['sequence_count'],
-                    'alignment_length': ml_results['alignment_length'],
-                    'ml_tree_available': True
-                }
-
-                # Store ML tree for later use
-                self.ml_tree = ml_results['tree']
-                self.ml_alignment = ml_results.get('alignment')
-
-                print("✓ Tree structure enhanced with ML analysis")
-            else:
-                tree_structure['ml_analysis'] = {
-                    'ml_tree_available': False,
-                    'error': 'ML analysis failed'
-                }
-                print("⚠️ ML analysis failed, using standard tree structure")
-
-            return tree_structure
-
-        except Exception as e:
-            print(f"Error building ML-enhanced tree structure: {e}")
-            # Fallback to original method
-            try:
-                return self.build_tree_structure(matched_ids)
-            except Exception as e2:
-                print(f"Fallback also failed: {e2}")
-                return {'error': 'Both ML and standard tree construction failed'}
-
-
-    def _print_tree_topology(self, tree, max_depth=3, current_depth=0, prefix=""):
-
-        if current_depth > max_depth:
-            return
-
-        try:
-            # Get all clades at current level
-            clades = list(tree.find_clades())
-
-            for i, clade in enumerate(clades[:5]):  # Limit to first 5 for readability
-                branch_info = ""
-                if clade.branch_length is not None:
-                    branch_info = f" (len: {clade.branch_length:.4f})"
-
-                if clade.is_terminal():
-                    node_name = clade.name or "Terminal"
-                    print(f"   {prefix}├── {node_name}{branch_info}")
-                else:
-                    node_name = clade.name or f"Internal_{i}"
-                    print(f"   {prefix}├── {node_name}{branch_info}")
-
-                if current_depth < max_depth - 1 and not clade.is_terminal():
-                    # Show children (simplified)
-                    children = list(clade.find_clades())
-                    if len(children) > 1:
-                        for j, child in enumerate(children[1:3]):  # Show max 2 children
-                            child_name = child.name or f"Node_{j}"
-                            child_branch = f" (len: {child.branch_length:.4f})" if child.branch_length else ""
-                            print(f"   {prefix}│   ├── {child_name}{child_branch}")
-
-        except Exception as e:
-            print(f"   Error displaying topology: {e}")
-
-
-
-def main():
-    print("\n" + "="*70)
-    print("🧬 PHYLOGENETIC TREE ANALYZER - ADVANCED ML-BASED ANALYSIS")
-    print("="*70)
-    print("Version 2.0 | AI-Enhanced Similarity Matching")
-    print("Interactive Visualization with Variable Line Lengths")
-    print("="*70)
-
-    # Initialize the analyzer
-    analyzer = PhylogeneticTreeAnalyzer()
-
-    try:
-        # Step 1: Load data
-        while True:
-            data_file = "f cleaned.csv"
-            if not data_file:
-                print("❌ Please provide a file path.")
-                continue
-
-            if not Path(data_file).exists():
-                print(f"❌ File not found: {data_file}")
-                continue
-
-            if analyzer.load_data(data_file):
-                break
-            else:
-                print("❌ Failed to load data. Please check file format.")
-                continue
-
-        # Step 2: Train AI model automatically
-        print("\n⏳ Training AI model... This may take a few moments.", flush=True)
-        start_time = time.time()
-        if analyzer.train_ai_model():
-            elapsed = time.time() - start_time
-            print(f"✅ AI model training completed in {elapsed:.1f} seconds", flush=True)
-        else:
-            print("⚠️ AI model training failed, continuing with basic analysis", flush=True)
-
-        # Step 3: Get query sequence
-        while True:
-            print("\n🔍 QUERY SEQUENCE INPUT:")
-            print("   You can provide:")
-            print("   1. Accession Number (e.g., 'MH087032') - from your dataset")
-            print("   2. ANY F-gene nucleotide sequence (A, T, G, C)")
-            print("   3. Novel sequences will be compared against your dataset")
-            print("   Note: Minimum sequence length is 10 nucleotides")
-
-            query_input = input("\nEnter query sequence or ID: ").strip()
-            if not query_input:
-                print("❌ Please provide a query sequence or ID.")
-                continue
-
-            if analyzer.find_query_sequence(query_input):
-                break
-            else:
-                retry = input("❌ Invalid input. Try again? (y/n): ").strip().lower()
-                if retry != 'y':
-                    print("👋 Analysis cancelled.")
-                    return
-
-        # Step 4: Set similarity percentage
-        while True:
-            try:
-                print(f"\n📊 SIMILARITY THRESHOLD:")
-                print(f"   - Higher values (90-99%): Find very similar sequences")
-                print(f"   - Lower values (70-89%): Find more distantly related sequences")
-
-                similarity_input = input(f"Enter target similarity percentage (1-99) [85]: ").strip()
-                if not similarity_input:
-                    target_percentage = 85.0  # Lowered default for novel sequences
-                else:
-                    target_percentage = float(similarity_input)
-
-                if not (1 <= target_percentage <= 99):
-                    print("❌ Please enter a percentage between 1 and 99.")
-                    continue
-
-                analyzer.matching_percentage = target_percentage
-                break
-
-            except ValueError:
-                print("❌ Please enter a valid number.")
-                continue
-
-        # Step 5: Find similar sequences
-        print(f"\n⏳ Analyzing sequences for {target_percentage}% similarity...")
-        start_time = time.time()
-
-        matched_ids, actual_percentage = analyzer.find_similar_sequences(target_percentage)
-
-        if not matched_ids:
-            print(f"❌ No similar sequences found at {target_percentage}% similarity.")
-            print("💡 Try lowering the similarity percentage (e.g., 70-80%) to find more distant matches.")
-            return
-
-        analyzer.matched_sequences = matched_ids
-        analyzer.actual_percentage = actual_percentage
-
-        elapsed = time.time() - start_time
-        print(f"✅ Similarity analysis completed in {elapsed:.1f} seconds")
-
-        # Step 6: Build tree structure
-        print("\n⏳ Building phylogenetic tree structure...")
-        start_time = time.time()
-
-        tree_structure = analyzer.build_tree_structure_with_ml_safe(matched_ids)
-        if not tree_structure:
-            print("❌ Failed to build tree structure.")
-            return
-
-        elapsed = time.time() - start_time
-        print(f"✅ Tree structure built in {elapsed:.1f} seconds")
-
-        # Step 7: Create visualization and save HTML
-        print("\n⏳ Creating interactive visualization...")
-        start_time = time.time()
-
-        fig = analyzer.create_interactive_tree(matched_ids, actual_percentage)
-        if fig:
-            elapsed = time.time() - start_time
-            print(f"✅ Visualization created in {elapsed:.1f} seconds")
-
-            # Save the interactive HTML file
-            html_filename = "phylogenetic_tree_interactive.html"
-            fig.write_html(html_filename)
-            print(f"📄 Interactive HTML saved: {html_filename}")
-
-            print(f"\n🎉 Analysis completed successfully!")
-            print(f"   Query ID: {analyzer.query_id}")
-            print(f"   Query sequence length: {len(analyzer.query_sequence)} nucleotides")
-            print(f"   Similar sequences found: {len(matched_ids)}")
-            print(f"   Actual similarity percentage: {actual_percentage:.1f}%")
-            print(f"   HTML file generated: {html_filename}")
-        else:
-            print("❌ Visualization creation failed.")
-            return
-
-    except KeyboardInterrupt:
-        print(f"\n\n⚠️ Analysis interrupted by user.")
-        sys.exit(1)
-    except Exception as e:
-        print(f"\n❌ An error occurred during analysis: {e}")
-        print(f"Please check your input data and try again.")
-        sys.exit(1)
-
-
-def command_line_interface():
-    parser = argparse.ArgumentParser(
-        description="Advanced Phylogenetic Tree Analyzer with AI-enhanced similarity matching",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-#   %(prog)s -d data.csv -q MH087032 -s 95
-#   %(prog)s -d data.csv -q MH087032 -s 90 --no-ai --batch query1,query2,query3
-        """
-    )
-
-    parser.add_argument('-d', '--data', required=True,
-                       help='Path to CSV data file')
-    parser.add_argument('-q', '--query', required=True,
-                       help='Query sequence ID or nucleotide sequence')
-    parser.add_argument('-s', '--similarity', type=float, default=95.0,
-                       help='Target similarity percentage (70-99, default: 95)')
-    parser.add_argument('--no-ai', action='store_true',
-                       help='Skip AI model training')
-    parser.add_argument('--batch',
-                       help='Comma-separated list of query IDs for batch processing')
-    parser.add_argument('--output-dir', default='.',
-                       help='Output directory for results')
-    parser.add_argument('--save-json', action='store_true',
-                       help='Save detailed results to JSON')
-
-    args = parser.parse_args()
-
-    # Validate arguments
-    if not (70 <= args.similarity <= 99):
-        print("❌ Similarity percentage must be between 70 and 99.")
-        sys.exit(1)
-
-    if not Path(args.data).exists():
-        print(f"❌ Data file not found: {args.data}")
-        sys.exit(1)
-
-    # Initialize analyzer
-    analyzer = PhylogeneticTreeAnalyzer()
-
-    # Load data
-    if not analyzer.load_data(args.data):
-        print("❌ Failed to load data.")
-        sys.exit(1)
-
-    # Train AI model (unless disabled)
-    if not args.no_ai:
-        print("\n⏳ Training AI model... This may take a few moments.", flush=True)
-        start_time = time.time()
-        if analyzer.train_ai_model():
-            elapsed = time.time() - start_time
-            print(f"✅ AI model training completed in {elapsed:.1f} seconds", flush=True)
-        else:
-            print("⚠️ AI model training failed, continuing with basic analysis", flush=True)
-
-    # Process queries
-    queries = args.batch.split(',') if args.batch else [args.query]
-
-    for query in queries:
-        query = query.strip()
-        print(f"\n🔍 Processing: {query}")
-
-        if analyzer.find_query_sequence(query):
-            matched_ids, actual_percentage = analyzer.find_similar_sequences(args.similarity)
-
-            if matched_ids:
-                analyzer.build_tree_structure_with_ml_safe(matched_ids)
-                fig = analyzer.create_interactive_tree(matched_ids, actual_percentage)
-
-                if fig:
-                    # Save the interactive HTML file
-                    html_filename = f"phylogenetic_tree_{query.replace('/', '_')}_interactive.html"
-                    fig.write_html(html_filename)
-                    print(f"📄 Interactive HTML saved: {html_filename}")
-
-                print(f"✅ Analysis completed for {query}")
-            else:
-                print(f"❌ No similar sequences found for {query}")
-        else:
-            print(f"❌ Query not found: {query}")
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except KeyboardInterrupt:
-        print(f"\n\n👋 Goodbye!")
-        sys.exit(0)
-    except Exception as e:
-        print(f"\n❌ Unexpected error: {e}")
-        sys.exit(1)
-            #KR815908