vector-inspector 0.2.6__py3-none-any.whl → 0.3.1__py3-none-any.whl

vector_inspector/ui/dialogs/cross_db_migration.py

@@ -0,0 +1,383 @@
+"""Cross-database operations for migrating data between vector databases."""
+
+from typing import Optional, List, Dict, Any
+from pathlib import Path
+import tempfile
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QLabel, QComboBox,
+    QPushButton, QProgressBar, QTextEdit, QGroupBox, QFormLayout,
+    QSpinBox, QCheckBox, QMessageBox
+)
+from PySide6.QtCore import QThread, Signal
+
+from vector_inspector.core.connection_manager import ConnectionManager, ConnectionInstance
+from vector_inspector.services.backup_restore_service import BackupRestoreService
+
+
+class MigrationThread(QThread):
+    """Background thread for migrating data between databases using backup/restore."""
+    
+    progress = Signal(int, str)  # progress percentage, status message
+    finished = Signal(bool, str)  # success, message
+    
+    def __init__(
+        self,
+        source_conn: ConnectionInstance,
+        target_conn: ConnectionInstance,
+        source_collection: str,
+        target_collection: str,
+        include_embeddings: bool
+    ):
+        super().__init__()
+        self.source_conn = source_conn
+        self.target_conn = target_conn
+        self.source_collection = source_collection
+        self.target_collection = target_collection
+        self.include_embeddings = include_embeddings
+        self._cancelled = False
+        self.backup_service = BackupRestoreService()
+    
+    def cancel(self):
+        """Cancel the migration."""
+        self._cancelled = True
+    
+    def run(self):
+        """Run the migration using backup and restore."""
+        temp_backup_path = None
+        try:
+            if self._cancelled:
+                self.finished.emit(False, "Migration cancelled by user.")
+                return
+            
+            # Ensure connections are active
+            if not self.source_conn.connection.is_connected:
+                self.finished.emit(False, "Source connection is not active.")
+                return
+            
+            if not self.target_conn.connection.is_connected:
+                self.finished.emit(False, "Target connection is not active.")
+                return
+            
+            # Create temporary directory for backup
+            temp_dir = tempfile.mkdtemp(prefix="vector_migration_")
+            
+            # Step 1: Create backup of source collection
+            self.progress.emit(10, f"Creating backup of {self.source_collection}...")
+            
+            temp_backup_path = self.backup_service.backup_collection(
+                self.source_conn.connection,
+                self.source_collection,
+                temp_dir,
+                include_embeddings=self.include_embeddings
+            )
+            
+            if not temp_backup_path:
+                self.finished.emit(False, "Failed to create backup.")
+                return
+            
+            if self._cancelled:
+                self.finished.emit(False, "Migration cancelled by user.")
+                return
+            
+            # Step 2: Restore to target collection
+            self.progress.emit(50, f"Restoring to {self.target_collection}...")
+            
+            # Verify target connection before restore
+            if not self.target_conn.connection.is_connected:
+                # Try to reconnect
+                if not self.target_conn.connection.connect():
+                    self.finished.emit(False, "Target connection lost. Please try again.")
+                    return
+            
+            # Check if target collection exists
+            target_exists = self.target_collection in self.target_conn.collections
+            
+            success = self.backup_service.restore_collection(
+                self.target_conn.connection,
+                temp_backup_path,
+                collection_name=self.target_collection,
+                overwrite=target_exists
+            )
+            
+            if self._cancelled:
+                self.finished.emit(False, "Migration cancelled by user.")
+                return
+            
+            if success:
+                self.progress.emit(100, f"Migration complete!")
+                self.finished.emit(True, f"Successfully migrated {self.source_collection} to {self.target_collection}")
+            else:
+                # Clean up target collection on failure
+                try:
+                    if self.target_collection in self.target_conn.connection.list_collections():
+                        self.progress.emit(90, "Cleaning up failed migration...")
+                        print(f"Cleaning up failed migration: deleting target collection '{self.target_collection}'")
+                        self.target_conn.connection.delete_collection(self.target_collection)
+                except Exception as cleanup_error:
+                    print(f"Warning: Failed to clean up target collection: {cleanup_error}")
+                
+                self.finished.emit(False, "Failed to restore to target collection. Target collection cleaned up.")
+        
+        except Exception as e:
+            import traceback
+            error_details = traceback.format_exc()
+            print(f"Migration error details:\n{error_details}")
+            
+            # Clean up target collection on exception
+            try:
+                if self.target_conn and self.target_conn.connection.is_connected:
+                    if self.target_collection in self.target_conn.connection.list_collections():
+                        print(f"Cleaning up failed migration: deleting target collection '{self.target_collection}'")
+                        self.target_conn.connection.delete_collection(self.target_collection)
+            except Exception as cleanup_error:
+                print(f"Warning: Failed to clean up target collection: {cleanup_error}")
+            
+            self.finished.emit(False, f"Migration error: {str(e)}")
+        
+        finally:
+            # Clean up temporary backup file
+            if temp_backup_path:
+                try:
+                    Path(temp_backup_path).unlink()
+                    # Also remove temp directory if empty
+                    temp_dir = Path(temp_backup_path).parent
+                    if temp_dir.exists() and not list(temp_dir.iterdir()):
+                        temp_dir.rmdir()
+                except Exception:
+                    pass  # Ignore cleanup errors
+
+
+class CrossDatabaseMigrationDialog(QDialog):
+    """Dialog for migrating data between vector databases."""
+    
+    def __init__(self, connection_manager: ConnectionManager, parent=None):
+        super().__init__(parent)
+        self.connection_manager = connection_manager
+        self.migration_thread: Optional[MigrationThread] = None
+        
+        self.setWindowTitle("Cross-Database Migration")
+        self.setMinimumWidth(600)
+        self.setMinimumHeight(400)
+        
+        self._setup_ui()
+        self._populate_connections()
+    
+    def _setup_ui(self):
+        """Setup the UI."""
+        layout = QVBoxLayout(self)
+        
+        # Source section
+        source_group = QGroupBox("Source")
+        source_layout = QFormLayout()
+        
+        self.source_connection_combo = QComboBox()
+        self.source_connection_combo.currentIndexChanged.connect(self._on_source_connection_changed)
+        source_layout.addRow("Connection:", self.source_connection_combo)
+        
+        self.source_collection_combo = QComboBox()
+        source_layout.addRow("Collection:", self.source_collection_combo)
+        
+        source_group.setLayout(source_layout)
+        layout.addWidget(source_group)
+        
+        # Target section
+        target_group = QGroupBox("Target")
+        target_layout = QFormLayout()
+        
+        self.target_connection_combo = QComboBox()
+        self.target_connection_combo.currentIndexChanged.connect(self._on_target_connection_changed)
+        target_layout.addRow("Connection:", self.target_connection_combo)
+        
+        self.target_collection_combo = QComboBox()
+        self.target_collection_combo.setEditable(True)
+        target_layout.addRow("Collection:", self.target_collection_combo)
+        
+        self.create_new_check = QCheckBox("Create new collection if it doesn't exist")
+        self.create_new_check.setChecked(True)
+        target_layout.addRow("", self.create_new_check)
+        
+        target_group.setLayout(target_layout)
+        layout.addWidget(target_group)
+        
+        # Options
+        options_group = QGroupBox("Options")
+        options_layout = QFormLayout()
+        
+        self.include_embeddings_check = QCheckBox("Include Embeddings")
+        self.include_embeddings_check.setChecked(True)
+        options_layout.addRow("", self.include_embeddings_check)
+        
+        options_group.setLayout(options_layout)
+        layout.addWidget(options_group)
+        
+        # Progress section
+        self.progress_bar = QProgressBar()
+        self.progress_bar.setRange(0, 100)
+        self.progress_bar.setValue(0)
+        layout.addWidget(self.progress_bar)
+        
+        self.status_text = QTextEdit()
+        self.status_text.setReadOnly(True)
+        self.status_text.setMaximumHeight(100)
+        layout.addWidget(self.status_text)
+        
+        # Buttons
+        button_layout = QHBoxLayout()
+        
+        self.start_button = QPushButton("Start Migration")
+        self.start_button.clicked.connect(self._start_migration)
+        button_layout.addWidget(self.start_button)
+        
+        self.cancel_button = QPushButton("Cancel")
+        self.cancel_button.clicked.connect(self._cancel_migration)
+        self.cancel_button.setEnabled(False)
+        button_layout.addWidget(self.cancel_button)
+        
+        self.close_button = QPushButton("Close")
+        self.close_button.clicked.connect(self.close)
+        button_layout.addWidget(self.close_button)
+        
+        layout.addLayout(button_layout)
+    
+    def _populate_connections(self):
+        """Populate connection dropdowns."""
+        connections = self.connection_manager.get_all_connections()
+        
+        self.source_connection_combo.clear()
+        self.target_connection_combo.clear()
+        
+        for conn in connections:
+            self.source_connection_combo.addItem(conn.get_display_name(), conn.id)
+            self.target_connection_combo.addItem(conn.get_display_name(), conn.id)
+        
+        # Populate collections for first connection
+        if connections:
+            self._on_source_connection_changed(0)
+            self._on_target_connection_changed(0)
+    
+    def _on_source_connection_changed(self, index: int):
+        """Handle source connection change."""
+        connection_id = self.source_connection_combo.currentData()
+        if connection_id:
+            instance = self.connection_manager.get_connection(connection_id)
+            if instance:
+                self.source_collection_combo.clear()
+                self.source_collection_combo.addItems(instance.collections)
+    
+    def _on_target_connection_changed(self, index: int):
+        """Handle target connection change."""
+        connection_id = self.target_connection_combo.currentData()
+        if connection_id:
+            instance = self.connection_manager.get_connection(connection_id)
+            if instance:
+                self.target_collection_combo.clear()
+                self.target_collection_combo.addItems(instance.collections)
+    
+    def _start_migration(self):
+        """Start the migration."""
+        # Validate selection
+        source_conn_id = self.source_connection_combo.currentData()
+        target_conn_id = self.target_connection_combo.currentData()
+        
+        if not source_conn_id or not target_conn_id:
+            QMessageBox.warning(self, "Invalid Selection", "Please select both source and target connections.")
+            return
+        
+        if source_conn_id == target_conn_id:
+            source_coll = self.source_collection_combo.currentText()
+            target_coll = self.target_collection_combo.currentText()
+            if source_coll == target_coll:
+                QMessageBox.warning(
+                    self,
+                    "Invalid Selection",
+                    "Source and target cannot be the same collection in the same connection."
+                )
+                return
+        
+        source_conn = self.connection_manager.get_connection(source_conn_id)
+        target_conn = self.connection_manager.get_connection(target_conn_id)
+        
+        if not source_conn or not target_conn:
+            QMessageBox.warning(self, "Error", "Failed to get connection instances.")
+            return
+        
+        source_collection = self.source_collection_combo.currentText()
+        target_collection = self.target_collection_combo.currentText().strip()
+        
+        if not source_collection or not target_collection:
+            QMessageBox.warning(self, "Invalid Selection", "Please select both source and target collections.")
+            return
+        
+        # Check if target collection exists
+        target_exists = target_collection in target_conn.collections
+        
+        # If target doesn't exist and we're not set to create, warn user
+        if not target_exists and not self.create_new_check.isChecked():
+            QMessageBox.warning(
+                self,
+                "Collection Does Not Exist",
+                f"Target collection '{target_collection}' does not exist.\n"
+                "Please check 'Create new collection' to allow automatic creation during migration."
+            )
+            return
+        
+        # Confirm
+        action = "create and migrate" if not target_exists else "migrate"
+        reply = QMessageBox.question(
+            self,
+            "Confirm Migration",
+            f"Migrate data from:\n  {source_conn.name}/{source_collection}\n"
+            f"to:\n  {target_conn.name}/{target_collection}\n\n"
+            f"This will {action} all data. Continue?",
+            QMessageBox.Yes | QMessageBox.No
+        )
+        
+        if reply != QMessageBox.Yes:
+            return
+        
+        # Start migration thread
+        self.migration_thread = MigrationThread(
+            source_conn=source_conn,
+            target_conn=target_conn,
+            source_collection=source_collection,
+            target_collection=target_collection,
+            include_embeddings=self.include_embeddings_check.isChecked()
+        )
+        
+        self.migration_thread.progress.connect(self._on_migration_progress)
+        self.migration_thread.finished.connect(self._on_migration_finished)
+        
+        self.start_button.setEnabled(False)
+        self.cancel_button.setEnabled(True)
+        self.close_button.setEnabled(False)
+        
+        self.status_text.clear()
+        self.progress_bar.setValue(0)
+        
+        self.migration_thread.start()
+    
+    def _cancel_migration(self):
+        """Cancel the migration."""
+        if self.migration_thread:
+            self.migration_thread.cancel()
+            self.status_text.append("Cancelling migration...")
+    
+    def _on_migration_progress(self, progress: int, message: str):
+        """Handle migration progress update."""
+        self.progress_bar.setValue(progress)
+        self.status_text.append(message)
+    
+    def _on_migration_finished(self, success: bool, message: str):
+        """Handle migration completion."""
+        self.status_text.append(message)
+        
+        if success:
+            QMessageBox.information(self, "Success", message)
+        else:
+            QMessageBox.warning(self, "Failed", message)
+        
+        self.start_button.setEnabled(True)
+        self.cancel_button.setEnabled(False)
+        self.close_button.setEnabled(True)
+        self.migration_thread = None
+

vector_inspector/ui/dialogs/embedding_config_dialog.py

@@ -0,0 +1,315 @@
+"""Dialog for configuring embedding models for collections (Step 2: Model Selection)."""
+
+from typing import Optional, Tuple
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QLabel, 
+    QComboBox, QPushButton, QGroupBox, QTextEdit,
+    QMessageBox, QLineEdit, QFormLayout
+)
+from PySide6.QtCore import Qt
+
+from vector_inspector.core.embedding_utils import get_available_models_for_dimension
+from vector_inspector.core.model_registry import get_model_registry
+
+
+class EmbeddingConfigDialog(QDialog):
+    """Dialog for selecting embedding model for a collection."""
+    
+    def __init__(self, collection_name: str, vector_dimension: int, 
+                 provider_type: Optional[str] = None,
+                 current_model: Optional[str] = None, 
+                 current_type: Optional[str] = None,
+                 parent=None):
+        super().__init__(parent)
+        self.collection_name = collection_name
+        self.vector_dimension = vector_dimension
+        self.provider_type = provider_type  # Filter by this type
+        self.current_model = current_model
+        self.current_type = current_type
+        self.selected_model = None
+        self.selected_type = None
+        
+        # Determine title based on provider type
+        if provider_type == "custom":
+            title = "Enter Custom Model"
+        elif provider_type:
+            type_names = {
+                "sentence-transformer": "Sentence Transformers",
+                "clip": "CLIP Models",
+                "openai": "OpenAI API",
+                "cohere": "Cohere API",
+                "vertex-ai": "Google Vertex AI",
+                "voyage": "Voyage AI"
+            }
+            type_name = type_names.get(provider_type, provider_type.title())
+            title = f"Select Model: {type_name}"
+        else:
+            title = f"Configure Embedding Model - {collection_name}"
+        
+        self.setWindowTitle(title)
+        self.setMinimumWidth(500)
+        self._setup_ui()
+        
+    def _setup_ui(self):
+        """Setup dialog UI."""
+        layout = QVBoxLayout(self)
+
+        # Handle custom model entry case
+        if self.provider_type == "custom":
+            self._setup_custom_ui(layout)
+            return
+        
+        # Info section
+        info_group = QGroupBox("Collection Information")
+        info_layout = QVBoxLayout()
+        
+        info_layout.addWidget(QLabel(f"<b>Collection:</b> {self.collection_name}"))
+        info_layout.addWidget(QLabel(f"<b>Vector Dimension:</b> {self.vector_dimension}"))
+        
+        if self.current_model:
+            info_layout.addWidget(QLabel(f"<b>Current Model:</b> {self.current_model} ({self.current_type})"))
+        else:
+            warning = QLabel("⚠️ No embedding model configured - using automatic detection")
+            warning.setStyleSheet("color: orange;")
+            info_layout.addWidget(warning)
+        
+        info_group.setLayout(info_layout)
+        layout.addWidget(info_group)
+        
+        # Model selection section
+        model_group = QGroupBox("Embedding Model Selection")
+        model_layout = QVBoxLayout()
+        
+        # Get available models for this dimension, filtered by provider type
+        if self.provider_type:
+            registry = get_model_registry()
+            registry_models = registry.get_models_by_dimension(self.vector_dimension)
+            filtered_models = [m for m in registry_models if m.type == self.provider_type]
+            available_models = [(m.name, m.type, m.description) for m in filtered_models]
+            
+            # Add custom models from settings
+            try:
+                from ...services.settings_service import SettingsService
+                settings = SettingsService()
+                custom_models = settings.get_custom_embedding_models(self.vector_dimension)
+                for model in custom_models:
+                    if model["type"] == self.provider_type:
+                        available_models.append((
+                            model["name"],
+                            model["type"],
+                            f"{model['description']} (custom)"
+                        ))
+            except Exception:
+                pass
+        else:
+            available_models = get_available_models_for_dimension(self.vector_dimension)
+        
+        if available_models:
+            model_layout.addWidget(QLabel(f"Available models for {self.vector_dimension}-dimensional vectors:"))
+
+            self.model_combo = QComboBox()
+            for model_name, model_type, description in available_models:
+                display_text = f"{model_name} ({model_type}) - {description}"
+                self.model_combo.addItem(display_text, (model_name, model_type))
+
+            # Set current selection if it matches
+            if self.current_model and self.current_type:
+                for i in range(self.model_combo.count()):
+                    model_name, model_type = self.model_combo.itemData(i)
+                    if model_name == self.current_model and model_type == self.current_type:
+                        self.model_combo.setCurrentIndex(i)
+                        break
+
+            model_layout.addWidget(self.model_combo)
+
+            # Description area
+            desc_label = QLabel("<b>About the selected model:</b>")
+            model_layout.addWidget(desc_label)
+
+            self.description_text = QTextEdit()
+            self.description_text.setReadOnly(True)
+            self.description_text.setMaximumHeight(100)
+            self.description_text.setStyleSheet("background-color: #f5f5f5; border: 1px solid #ccc; color: #000000;")
+            model_layout.addWidget(self.description_text)
+
+            # Update description when selection changes
+            self.model_combo.currentIndexChanged.connect(self._update_description)
+            self._update_description()
+
+        else:
+            # No models for this type + dimension
+            type_name = self.provider_type or "any type"
+            warning = QLabel(f"⚠️ No models of type '{type_name}' available for {self.vector_dimension} dimensions.")
+            warning.setWordWrap(True)
+            model_layout.addWidget(warning)
+
+            registry = get_model_registry()
+            all_dims = registry.get_all_dimensions()
+            dims_text = "Available dimensions: " + ", ".join(str(d) for d in sorted(all_dims))
+            model_layout.addWidget(QLabel(dims_text))
+
+            self.model_combo = None
+        
+        model_group.setLayout(model_layout)
+        layout.addWidget(model_group)
+        
+        # Buttons
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+        
+        self.save_btn = QPushButton("Save Configuration")
+        self.save_btn.clicked.connect(self._on_save)
+        # Always enabled - user can choose from combo OR enter custom
+        self.save_btn.setEnabled(True)
+        
+        self.clear_btn = QPushButton("Clear Configuration")
+        self.clear_btn.clicked.connect(self._clear_config)
+        self.clear_btn.setEnabled(self.current_model is not None)
+        
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+        
+        button_layout.addWidget(self.save_btn)
+        button_layout.addWidget(self.clear_btn)
+        button_layout.addWidget(cancel_btn)
+        
+        layout.addLayout(button_layout)
+    
+    def _setup_custom_ui(self, layout):
+        """Setup UI for custom model entry."""
+        # Info section
+        info_group = QGroupBox("Collection Information")
+        info_layout = QVBoxLayout()
+        info_layout.addWidget(QLabel(f"<b>Collection:</b> {self.collection_name}"))
+        info_layout.addWidget(QLabel(f"<b>Vector Dimension:</b> {self.vector_dimension}"))
+        info_group.setLayout(info_layout)
+        layout.addWidget(info_group)
+
+        # Custom model entry section
+        custom_group = QGroupBox("Enter Custom Model Details")
+        custom_layout = QFormLayout()
+
+        self.custom_name_input = QLineEdit()
+        self.custom_name_input.setPlaceholderText("e.g., sentence-transformers/all-mpnet-base-v2")
+        custom_layout.addRow("Model Name:", self.custom_name_input)
+
+        self.custom_type_combo = QComboBox()
+        self.custom_type_combo.addItems(["sentence-transformer", "clip", "openai", "cohere", "vertex-ai", "voyage", "custom"])
+        custom_layout.addRow("Model Type:", self.custom_type_combo)
+
+        self.custom_desc_input = QLineEdit()
+        self.custom_desc_input.setPlaceholderText("Brief description (optional)")
+        custom_layout.addRow("Description:", self.custom_desc_input)
+
+        custom_note = QLabel("💡 Custom models will be saved and available for future use with this dimension.")
+        custom_note.setWordWrap(True)
+        custom_note.setStyleSheet("color: #666; font-size: 10px; padding: 4px;")
+        custom_layout.addRow(custom_note)
+
+        custom_group.setLayout(custom_layout)
+        layout.addWidget(custom_group)
+
+        # Buttons for custom entry
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+
+        save_btn = QPushButton("Save")
+        save_btn.clicked.connect(self._save_custom_model)
+        save_btn.setDefault(True)
+
+        button_layout.addWidget(cancel_btn)
+        button_layout.addWidget(save_btn)
+
+        layout.addLayout(button_layout)
+
+        # No combo or description for custom mode
+        self.model_combo = None
+    
+    def _save_custom_model(self):
+        """Save custom model entry."""
+        custom_name = self.custom_name_input.text().strip()
+        custom_desc = self.custom_desc_input.text().strip()
+        custom_type = self.custom_type_combo.currentText()
+
+        if not custom_name:
+            QMessageBox.warning(self, "Invalid Input", "Please enter a model name.")
+            return
+
+        # Save custom model to registry
+        from vector_inspector.services.settings_service import SettingsService
+        settings = SettingsService()
+
+        settings.add_custom_embedding_model(
+            model_name=custom_name,
+            dimension=self.vector_dimension,
+            model_type=custom_type,
+            description=custom_desc if custom_desc else f"Custom {custom_type} model"
+        )
+
+        # Set selection to custom model
+        self.selected_model = custom_name
+        self.selected_type = custom_type
+        self.accept()
+    
+    def _update_description(self):
+        """Update the description text based on selected model."""
+        if not self.model_combo:
+            return
+        
+        model_name, model_type = self.model_combo.currentData()
+        
+        descriptions = {
+            "sentence-transformer": (
+                "Sentence-Transformers are text-only embedding models optimized for semantic similarity. "
+                "They work well for text search, clustering, and classification tasks."
+            ),
+            "clip": (
+                "CLIP (Contrastive Language-Image Pre-training) is a multi-modal model that can embed both "
+                "text and images into the same vector space. This allows text queries to find semantically "
+                "similar images, and vice versa. Perfect for image search with text descriptions."
+            )
+        }
+        
+        desc = descriptions.get(model_type, "Embedding model for vector similarity search.")
+        self.description_text.setPlainText(
+            f"Model: {model_name}\n"
+            f"Type: {model_type}\n"
+            f"Dimension: {self.vector_dimension}\n\n"
+            f"{desc}"
+        )
+    
+    def _on_save(self):
+        """Handle save button click."""
+        if self.model_combo and self.model_combo.currentData():
+            # Use combo selection
+            model_name, model_type = self.model_combo.currentData()
+            self.selected_model = model_name
+            self.selected_type = model_type
+        else:
+            QMessageBox.warning(self, "No Selection", "Please select a model from the list.")
+            return
+        
+        self.accept()
+    
+    def _clear_config(self):
+        """Clear the embedding model configuration."""
+        reply = QMessageBox.question(
+            self,
+            "Clear Configuration",
+            "This will remove the custom embedding model configuration and use automatic detection. Continue?",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+        )
+        
+        if reply == QMessageBox.StandardButton.Yes:
+            self.selected_model = None
+            self.selected_type = None
+            self.done(2)  # Custom code for "clear"
+    
+    def get_selection(self) -> Optional[Tuple[str, str]]:
+        """Get the selected model and type (from either combo or custom entry)."""
+        if self.selected_model and self.selected_type:
+            return (self.selected_model, self.selected_type)
+        return None