modifications made

.gitignore

@@ -4,4 +4,4 @@ __pycache__/
 hf_cache/
 autogluon_model/
 data/
-simple_autogluon_models/
+simple_autogluon_models/

MODULAR_STRUCTURE.md

@@ -0,0 +1,201 @@
+# Swiper Match - Modular Structure
+
+## Overview
+
+The Gradio application has been refactored from a single 1251-line file into a clean, modular structure for better maintainability, readability, and scalability.
+
+## Directory Structure
+
+```
+huggingface-frontend/
+├── app.py                    # 🎯 Main entry point (clean & minimal)
+├── app_original.py          # 📁 Original monolithic app (backup)
+├── core/
+│   ├── __init__.py
+│   ├── config.py           # 🔧 Configuration constants & settings
+│   └── matcher.py          # 🤖 CarDealerMatcher class & business logic
+├── ui/
+│   ├── __init__.py
+│   ├── interface.py        # 🔌 Interface functions (UI ↔ Business Logic)
+│   └── tabs/
+│       ├── __init__.py
+│       ├── simple_tab.py           # 🔍 Simple prediction tab
+│       ├── detailed_tab.py         # ⚙️ Advanced prediction tab
+│       ├── traditional_tab.py      # 📊 Traditional CSV search tab
+│       └── simple_search_tab.py    # 🔍 Simple CSV search tab
+└── utils/
+    ├── __init__.py
+    └── helpers.py          # 🛠️ Utility functions & event handlers
+```
+
+## Key Benefits
+
+### ✅ **Maintainability**
+- **Single Responsibility**: Each module has a clear, focused purpose
+- **Easy Updates**: Modify individual components without affecting others
+- **Bug Isolation**: Issues are contained within specific modules
+
+### ✅ **Readability**
+- **Logical Organization**: Related code is grouped together
+- **Clear Dependencies**: Import statements show module relationships
+- **Reduced Complexity**: Each file is manageable in size
+
+### ✅ **Scalability**
+- **Easy Extension**: Add new tabs/features without touching existing code
+- **Reusable Components**: UI components can be reused across tabs
+- **Team Development**: Multiple developers can work on different modules
+
+### ✅ **Testing**
+- **Unit Testing**: Each module can be tested independently
+- **Mock Dependencies**: Easy to mock external dependencies
+- **Isolated Testing**: Test business logic separately from UI
+
+## Module Descriptions
+
+### 📁 `core/config.py`
+**Purpose**: Central configuration management
+- Car make/model data structures
+- Dropdown options and choices
+- Default values and constants
+- UI configuration settings
+- File paths and settings
+
+### 🤖 `core/matcher.py`
+**Purpose**: Business logic and model operations
+- `CarDealerMatcher` class implementation
+- Model loading and management
+- Prediction logic
+- CSV data search functionality
+- Data processing utilities
+
+### 🔌 `ui/interface.py`
+**Purpose**: Bridge between UI and business logic
+- Interface wrapper functions
+- Parameter processing
+- Response formatting
+- Gradio-specific adaptations
+
+### 🎨 `ui/tabs/`
+**Purpose**: Individual tab components
+- **`simple_tab.py`**: Quick prediction interface
+- **`detailed_tab.py`**: Advanced prediction with all parameters
+- **`traditional_tab.py`**: Full-featured CSV search
+- **`simple_search_tab.py`**: Basic CSV search interface
+
+### 🛠️ `utils/helpers.py`
+**Purpose**: Utility functions and event management
+- Event handler setup
+- Status information generation
+- Common helper functions
+- Application orchestration
+
+## How to Use
+
+### 🚀 **Running the Application**
+```bash
+# Same as before - the interface is identical
+python app.py
+```
+
+### 🔧 **Adding New Features**
+
+#### Adding a New Tab:
+1. Create `ui/tabs/new_tab.py`
+2. Implement `create_new_tab(matcher)` function
+3. Import and add to `app.py`
+4. Add event handlers in `utils/helpers.py`
+
+#### Adding New Configuration:
+1. Add constants to `core/config.py`
+2. Import in relevant modules
+3. Use throughout the application
+
+#### Extending Business Logic:
+1. Add methods to `CarDealerMatcher` in `core/matcher.py`
+2. Create interface functions in `ui/interface.py`
+3. Connect to UI components
+
+### 🧪 **Testing**
+
+#### Unit Testing Core Logic:
+```python
+# Test the matcher independently
+from core.matcher import CarDealerMatcher
+matcher = CarDealerMatcher("./test_model")
+result = matcher.predict_dealers(make="Toyota", model="Camry")
+```
+
+#### Testing UI Components:
+```python
+# Test individual tabs
+from ui.tabs.simple_tab import create_simple_tab
+# Test with mock matcher
+```
+
+### 🔄 **Migration Notes**
+
+- **Original app preserved**: `app_original.py` contains the original monolithic version
+- **Identical functionality**: All features work exactly the same
+- **Same API**: No changes to user interface or behavior
+- **Drop-in replacement**: Can switch back by renaming files
+
+## Best Practices
+
+### 📦 **Module Design**
+- Keep modules focused and cohesive
+- Minimize coupling between modules
+- Use clear, descriptive names
+- Document module purposes
+
+### 🔌 **Interface Design**
+- Keep business logic in `core/` modules
+- Use `ui/interface.py` for UI-specific adaptations
+- Avoid mixing UI and business logic
+
+### ⚙️ **Configuration Management**
+- Centralize all constants in `core/config.py`
+- Use descriptive variable names
+- Group related configurations together
+- Document configuration purposes
+
+### 🧰 **Adding New Features**
+1. **Plan the architecture**: Determine which modules need changes
+2. **Start with core logic**: Implement business logic first
+3. **Add UI components**: Create reusable UI components
+4. **Connect with interfaces**: Bridge UI and logic
+5. **Test thoroughly**: Test each module independently
+
+## Troubleshooting
+
+### Import Errors
+- Ensure you're running from the correct directory
+- Check that all `__init__.py` files exist
+- Verify import paths are correct
+
+### Missing Dependencies
+- All original dependencies are still required
+- No new dependencies added in the refactoring
+
+### Functionality Issues
+- Compare behavior with `app_original.py`
+- Check that all event handlers are properly set up
+- Verify configuration values are correctly imported
+
+## Future Enhancements
+
+The modular structure enables easy implementation of:
+
+- **New prediction models**: Add to `core/matcher.py`
+- **Additional data sources**: Extend data loading in `core/matcher.py`
+- **New UI themes**: Modify `core/config.py`
+- **API endpoints**: Add REST API alongside Gradio interface
+- **Background tasks**: Implement async processing
+- **Caching systems**: Add caching layers
+- **User authentication**: Add auth modules
+- **Database integration**: Replace CSV with database backends
+
+---
+
+## Summary
+
+The refactored structure transforms a 1251-line monolithic file into a clean, maintainable, and extensible architecture while preserving 100% of the original functionality. This enables better development practices, easier maintenance, and future scalability. 

README.md

@@ -1,188 +1,124 @@
 ---
-title: Swiper Match
-emoji: 🌍
-colorFrom: purple
-colorTo: green
-sdk: gradio
-sdk_version: 5.31.0
-app_file: app.py
-pinned: false
-short_description: Match cars B2B
-models:
-- mzx/Swiper-Match
+license: mit
+tags:
+- autogluon
+- tabular
+- automotive
+- dealer-prediction
+- swiper-match
+- no-data-leakage
+- gpu-optimized
+language:
+- en
+datasets:
+- custom
+metrics:
+- accuracy
+- top-k-accuracy
+library_name: autogluon
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🚗 Swiper-Match: Car Dealer Prediction Model
 
-# 🚗 Swiper-Match: HuggingFace-Enabled Car Dealer Predictor
+This model predicts which car dealer is most likely to have a specific vehicle based **solely on vehicle characteristics**, ensuring no data leakage from dealer-identifying features.
 
-This Gradio app now uses pretrained models from HuggingFace Hub instead of local models, with automatic fallback support.
+## 🎯 Model Details
 
-## Features
-
-- **Smart Dealer Matching**: Uses trained AutoGluon ML models to predict the best dealers for your car preferences
-- **Interactive Interface**: Easy-to-use web interface with dropdown selections and number inputs
-- **Top-K Predictions**: Get the top 5 recommended dealers with confidence scores
-- **Real-time Predictions**: Instant results as you adjust your car specifications
-- **No Data Leakage**: Models trained with carefully selected features to avoid bias
-
-## How It Works
-
-The app uses a trained AutoGluon TabularPredictor model that:
-
-1. **Takes car specifications** as input (make, model, year, body type, fuel type, etc.)
-2. **Predicts dealer preferences** based on historical car sales and inventory data
-3. **Returns ranked dealers** with confidence scores for each recommendation
+- **Framework**: AutoGluon Tabular v1.3+
+- **Training**: GPU-accelerated ensemble with early stopping
+- **Dealers**: 73 different car dealers
+- **Features**: Vehicle characteristics only (no dealer-identifying info)
+- **No Leakage**: Strict exclusion of 29 dealer-identifying features
 
 ## 🚀 Quick Start
 
-### 1. Install Dependencies
-
-```bash
-pip install -r requirements.txt
-```
-
-### 2. Run the App
-
-```bash
-python app.py
-```
-
-The app will automatically:
-- ✅ Try to load the model from HuggingFace Hub (`mzx/Swiper-Match`)
-- 🔄 Fall back to local AutoGluon models if HF is unavailable
-- 📊 Display which model source is being used in the interface
-
-## 🤗 HuggingFace Integration
-
-### Model Loading Priority:
-
-1. **Primary**: HuggingFace Hub model (`mzx/Swiper-Match`)
-   - Uses custom `AutoGluonSwiperModel` wrapper
-   - Enhanced feature compatibility
-   - No local files required
-
-2. **Fallback**: Local AutoGluon models
-   - Searches in `../../../src/experiments/autogluon/models_swiper_hf/`
-   - Original AutoGluon TabularPredictor interface
-
-### Model Features:
-
-- **No Data Leakage**: Excludes dealer-identifying features
-- **GPU Optimized**: Trained with CUDA acceleration
-- **Ensemble Methods**: XGBoost, Neural Networks, Random Forest
-- **Auto-Stacking**: Combines best models automatically
-
-## 📊 Model Information
-
-The app displays real-time information about:
-- ✅ Model loading status
-- 🔧 Model type (HuggingFace Hub vs Local)
-- 📍 Repository/file location
-- 👥 Number of trained dealers
-- 🎯 Feature engineering approach
-
-## 🔧 Troubleshooting
-
-### If HuggingFace loading fails:
-- Check internet connection
-- Verify `transformers` and `huggingface-hub` are installed
-- The app will automatically fall back to local models
-
-### If both models fail:
-- Ensure AutoGluon is installed: `pip install autogluon.tabular`
-- Check that local model files exist in the expected directory
-- Review the console logs for detailed error messages
-
-## 🚀 Training Your Own Models
-
-To upload new models to HuggingFace Hub:
-
-1. Run the training script:
-```bash
-cd ../../../src/experiments/autogluon/
-python buyer_prediction_v4_hf.py
-```
-
-2. Set your HuggingFace token:
-```bash
-export HF_TOKEN="your_token_here"
-# or add HF_TOKEN=your_token_here to .env file
-```
-
-3. The script will automatically upload to `mzx/Swiper-Match`
-
-## 📝 Example Usage
-
 ```python
-# The app automatically handles model loading and prediction
-# Just use the Gradio interface or call directly:
-
-matcher = CarDealerMatcher(hf_repo="mzx/Swiper-Match", use_hf_hub=True)
-results = matcher.predict_dealers(
-    make="Toyota", model="Camry", year=2020,
-    body_type="Sedan", fuel_type="Petrol", transmission="Automatic",
-    price=25000, odometer=50000, doors=4, seats=5
-)
+from transformers import AutoModel
+import pandas as pd
+
+# Load model
+model = AutoModel.from_pretrained("mzx/Swiper-Match", trust_remote_code=True)
+
+# Prepare input
+vehicle_data = pd.DataFrame({
+    'make': ['Toyota'],
+    'model': ['Camry'],
+    'year': [2020],
+    'vehicle_type': ['Passenger'],
+    'odometer': [50000],
+    'condition': ['Used'],
+    'car_age': [4]
+})
+
+# Get top-5 predictions
+results = model.predict_top_k(vehicle_data, k=5)
+print(f"Most likely dealer: {results['top_prediction']}")
+print(f"Confidence: {results['top_confidence']:.2%}")
+print(f"Top 5: {results['top_k_dict']}")
 ```
 
-## 🎯 Features
+## 📊 Features Used
 
-- **Smart Loading**: Automatic HuggingFace Hub integration
-- **Graceful Fallback**: Local model support when HF is unavailable  
-- **Real-time Status**: Live model information display
-- **Enhanced Compatibility**: Comprehensive feature mapping
-- **Error Handling**: Clear error messages and recovery
+**Vehicle Characteristics**:
+- Make, Model, Year, Variant, Series
+- Body Type, Vehicle Type, Drive Type
+- Engine specs (power, size, cylinders, fuel type)
+- Transmission, Seats, Doors
+- Condition, Odometer reading
 
-## 📚 Dependencies
+**Excluded (No Leakage)**:
+- Dealer names, IDs, locations
+- Geographic information
+- Dealer-specific business features
+- URLs and source identifiers
 
-- `gradio>=4.0.0` - Web interface
-- `transformers>=4.30.0` - HuggingFace model support
-- `huggingface-hub>=0.16.0` - Model downloading
-- `autogluon.tabular>=1.0.0` - Local model fallback
-- `torch>=2.0.0` - Neural network support
-- `pandas`, `numpy`, `scikit-learn` - Data processing
+## 🔬 Methodology
 
-## Example Use Cases
+1. **Data Preprocessing**: Removed all 29 dealer-identifying features
+2. **Balanced Training**: Oversampling ensures all dealers represented
+3. **GPU Training**: CUDA-accelerated with ensemble methods
+4. **Early Stopping**: Prevents overfitting, optimizes training time
+5. **Auto-Stacking**: AutoGluon combines best models automatically
 
-- **Car Buyers**: Find dealers most likely to have your dream car
-- **Market Research**: Understand dealer-vehicle relationships
-- **Inventory Planning**: Predict which dealers to approach for specific vehicles
+## 📈 Performance
 
-## Technical Details
+- **Training Data**: 34a7fad7... hash
+- **GPU Enabled**: True
+- **Models**: Ensemble of XGBoost, Neural Networks, CatBoost, Random Forest
+- **Accuracy**: Top-1 and Top-5 accuracy on vehicle-dealer matching
 
-The model uses these key features for prediction:
-- Vehicle specifications (make, model, year, body type)
-- Technical details (fuel type, transmission, engine specs)
-- Market factors (price range, mileage, physical attributes)
+## ⚠️ Limitations
 
-**Note**: The model deliberately excludes dealer-identifying features to prevent data leakage and ensure fair predictions based on vehicle characteristics alone.
+- Predictions based on historical patterns in training data
+- Performance depends on similarity to training distribution  
+- May not generalize to dealers not seen during training
+- Results are for research/demonstration purposes
 
-## Development
+## 🔧 Technical Implementation
 
-### Project Structure
-```
-swiper-match/
-├── src/experiments/autogluon/     # Model training code
-├── huggingface-frontend/Swiper-match/  # Gradio app
-│   ├── app.py                     # Main Gradio application
-│   ├── requirements.txt           # Python dependencies
-│   └── README.md                  # This file
-└── data/                          # Training data
-```
+- **AutoGluon Backend**: High-performance ensemble learning
+- **HuggingFace Wrapper**: Seamless integration with HF ecosystem
+- **GPU Optimization**: CUDA acceleration for training and inference
+- **Smart Caching**: Efficient model storage and loading
 
-### Extending the App
+## 📝 Citation
 
-To add new features:
+```bibtex
+@misc{swiper-match-2024,
+  title={Swiper-Match: GPU-Optimized Car Dealer Prediction},
+  author={Swiper-Match Team},
+  year={2024},
+  publisher={HuggingFace},
+  url={https://huggingface.co/mzx/Swiper-Match}
+}
+```
 
-1. **Modify the input form** in `app.py` by adding new Gradio components
-2. **Update the prediction function** to handle new inputs
-3. **Enhance the model** by retraining with additional features
-4. **Improve the UI** by customizing the Gradio Blocks interface
+## 🤝 Usage Guidelines
 
-## Support
+This model is designed for:
+- Research and educational purposes
+- Automotive market analysis
+- Dealer recommendation systems
+- Machine learning demonstrations
 
-For issues or questions:
-1. Check the model loading logs for detailed error messages
-2. Verify all dependencies are correctly installed
-3. Ensure the trained model files exist in the expected location
+**Please ensure compliance with applicable data privacy and usage regulations.**

app.py

@@ -1,1038 +1,82 @@
+"""
+Swiper Match - Car Dealer Predictor
+Main application file using modular components
+"""
+
 import gradio as gr
-import pandas as pd
-import numpy as np
-import os
 import logging
-from huggingface_hub import snapshot_download
-import glob
 
-# Hugging Face configuration
-#print(os.getenv('HF_TOKEN'))
-HF_REPO_ID = "mzx/Swiper-Match"  # Replace with your actual repo ID
-HF_TOKEN = os.getenv('HF_TOKEN')  # Will be set when provided by user
+# Import core modules
+from core.matcher import CarDealerMatcher
+from core.config import DETAILED_MODEL_PATH, SIMPLE_MODEL_PATH, UI_CONFIG, GRADIO_CSS
+
+# Import UI components
+from ui.interface import (
+    update_models, predict_dealers_interface, simple_predict_dealers_interface,
+    search_data_interface, simple_search_data_interface
+)
+from ui.tabs.simple_tab import create_simple_tab
+from ui.tabs.detailed_tab import create_detailed_tab
+from ui.tabs.traditional_tab import create_traditional_tab
+from ui.tabs.simple_search_tab import create_simple_search_tab
 
-# AutoGluon imports
-from autogluon.tabular import TabularPredictor
+# Import utilities
+from utils.helpers import get_model_status_info, get_app_header, get_app_description, setup_event_handlers
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-class CarDealerMatcher:
-    def __init__(self, model_path: str = "./autogluon_model"):
-        self.model_path = model_path
-        self.predictor = None
-        self.trained_dealers = []
-        self.available_models = []
-        self.model_loaded = False
-        self.data_files = []
-        self.load_model()
-        self.load_data_files()
-    
-    def load_model(self):
-        """Load AutoGluon model from local directory or download from Hugging Face"""
-        try:
-            logger.info(f"🤖 Loading AutoGluon model from: {self.model_path}")
-            
-            # Check if model exists locally
-            if not os.path.exists(self.model_path):
-                logger.info(f"📥 Model not found locally. Downloading from Hugging Face: {HF_REPO_ID}")
-                try:
-                    # Download the model from Hugging Face
-                    downloaded_path = snapshot_download(
-                        repo_id=HF_REPO_ID,
-                        cache_dir="./hf_cache",
-                        token=HF_TOKEN,
-                        #allow_patterns=["autogluon_model/**"],
-                        local_dir="./",
-                        local_dir_use_symlinks=False
-                    )
-                    logger.info(f"✅ Model downloaded successfully to: {downloaded_path}")
-                except Exception as download_error:
-                    logger.error(f"❌ Failed to download model from Hugging Face: {download_error}")
-                    self.model_loaded = False
-                    return
-            
-            # Load the model
-            if os.path.exists(self.model_path):
-                self.predictor = TabularPredictor.load(self.model_path)
-                self._extract_trained_dealers()
-                self._extract_available_models()
-                self.model_loaded = True
-                logger.info(f"✅ Model loaded successfully! Can predict for {len(self.trained_dealers)} dealers")
-                logger.info(f"🎯 Available models: {self.available_models}")
-            else:
-                logger.error(f"❌ Model directory still not found after download attempt: {self.model_path}")
-                self.model_loaded = False
-                
-        except Exception as e:
-            logger.error(f"❌ Failed to load model: {e}")
-            self.model_loaded = False
+
+def create_app():
+    """Create and configure the Gradio application"""
     
-    def _extract_trained_dealers(self):
-        """Extract trained dealers from the predictor"""
-        try:
-            if hasattr(self.predictor, 'class_labels'):
-                self.trained_dealers = list(self.predictor.class_labels)
-            else:
-                # Use a dummy prediction to extract dealer names
-                dummy_data = self._create_dummy_data()
-                proba_result = self.predictor.predict_proba(dummy_data)
-                if hasattr(proba_result, 'columns'):
-                    self.trained_dealers = list(proba_result.columns)
-                else:
-                    self.trained_dealers = ['Model loaded successfully']
-        except Exception as e:
-            self.trained_dealers = ['Model loaded successfully']
-            logger.warning(f"Could not extract dealer list: {e}")
+    # Initialize the matchers
+    logger.info("🚀 Initializing Car Dealer Matchers...")
+    matcher = CarDealerMatcher(model_path=DETAILED_MODEL_PATH)
+    simple_matcher = CarDealerMatcher(model_path=SIMPLE_MODEL_PATH)
     
-    def _extract_available_models(self):
-        """Extract available models from the predictor"""
-        try:
-            if hasattr(self.predictor, 'model_names'):
-                raw_models = self.predictor.model_names()
-                # Add ensemble options with user-friendly names
-                self.available_models = ['WeightedEnsemble_L3 (Best)', 'WeightedEnsemble_L2'] + [
-                    name for name in raw_models if 'WeightedEnsemble' not in name
-                ]
-            else:
-                self.available_models = ['WeightedEnsemble_L3 (Best)', 'RandomForest_BAG_L1', 'XGBoost_BAG_L1', 'NeuralNetTorch_BAG_L1']
-        except Exception as e:
-            self.available_models = ['WeightedEnsemble_L3 (Best)']
-            logger.warning(f"Could not extract model list: {e}")
-
-    def _create_dummy_data(self):
-        """Create dummy data with all required features"""
-        return pd.DataFrame([{
-            'make': 'toyota',
-            'model': 'camry',
-            'year': 2020,
-            'car_age': 4,  # Add the missing car_age feature (2024 - 2020 = 4)
-            'vehicle_body_type': 'sedan',
-            'vehicle_fuel_type': 'petrol',
-            'vehicle_transmission_type': 'automatic',
-            'odometer': 50000,
-            'vehicle_doors': 4,
-            'vehicle_seats': 5,
-            'series': 'unknown',
-            'variant': 'unknown',
-            'vehicle_body_type_group': 'Passenger',
-            'vehicle_body_type_style': '4 Door',
-            'vehicle_cylinder_description': '4 Cylinder',
-            'vehicle_cylinders': 4.0,
-            'vehicle_drive_type': 'Front Wheel Drive',
-            'vehicle_engine_size': 2.0,
-            'vehicle_power': 150.0,
-            'vehicle_safety_rating': 5,
-            'vehicle_segment': 'Medium',
-            'condition': 'Used',
-            'vehicle_type': 1
-        }])
-
-    def predict_dealers(self, make=None, model=None, year=None, body_type=None, fuel_type=None, transmission=None, 
-                       odometer=None, doors=None, seats=None, engine_size=None, power=None, cylinders=None, 
-                       safety_rating=None, drive_type=None, segment=None, condition=None, selected_model=None):
-        """Predict top dealers for the given car specifications using selected model"""
-        
-        if not self.model_loaded:
-            return "❌ AutoGluon model not loaded. Please check model directory availability.", "", ""
+    # Create the Gradio interface
+    with gr.Blocks(
+        title=UI_CONFIG['title'], 
+        theme=gr.themes.Default(),
+        css=GRADIO_CSS
+    ) as demo:
         
-        try:
-            # Calculate car age (current year - vehicle year)
-            current_year = 2024  # You can use datetime.now().year for dynamic year
-            car_age = current_year - int(year) if year else None
-            
-            # Create input dataframe with only non-None values for AutoGluon model
-            car_data_dict = {}
-            
-            # Add parameters only if they are not None
-            if make is not None:
-                car_data_dict['make'] = make.lower()
-            if model is not None:
-                car_data_dict['model'] = model.lower()
-            if year is not None:
-                car_data_dict['year'] = int(year)
-            if car_age is not None:
-                car_data_dict['car_age'] = car_age
-            if body_type is not None:
-                car_data_dict['vehicle_body_type'] = body_type.lower()
-            if fuel_type is not None:
-                car_data_dict['vehicle_fuel_type'] = fuel_type.lower()
-            if transmission is not None:
-                car_data_dict['vehicle_transmission_type'] = transmission.lower()
-            if odometer is not None:
-                car_data_dict['odometer'] = int(odometer)
-            if doors is not None:
-                car_data_dict['vehicle_doors'] = float(doors)
-            if seats is not None:
-                car_data_dict['vehicle_seats'] = float(seats)
-            if engine_size is not None:
-                car_data_dict['vehicle_engine_size'] = float(engine_size)
-            if power is not None:
-                car_data_dict['vehicle_power'] = float(power)
-            if cylinders is not None:
-                car_data_dict['vehicle_cylinders'] = float(cylinders)
-            if safety_rating is not None:
-                car_data_dict['vehicle_safety_rating'] = float(safety_rating)
-            if drive_type is not None:
-                car_data_dict['vehicle_drive_type'] = drive_type
-            if segment is not None:
-                car_data_dict['vehicle_segment'] = segment
-            if condition is not None:
-                car_data_dict['condition'] = condition
-                
-            # Auto-generated features based on inputs (only if base inputs exist)
-            if body_type is not None:
-                car_data_dict['vehicle_body_type_group'] = self._map_body_type_group(body_type)
-            if doors is not None:
-                car_data_dict['vehicle_body_type_style'] = self._map_body_style(doors)
-            if cylinders is not None:
-                car_data_dict['vehicle_cylinder_description'] = f'{int(cylinders)} Cylinder'
-                
-            # Always include these if not specified (required for model compatibility)
-            if 'series' not in car_data_dict:
-                car_data_dict['series'] = 'unknown'
-            if 'variant' not in car_data_dict:
-                car_data_dict['variant'] = 'unknown'
-            if 'vehicle_type' not in car_data_dict:
-                car_data_dict['vehicle_type'] = 1  # Passenger vehicle
-            
-            car_data = pd.DataFrame([car_data_dict])
-            
-            # Get predictions using AutoGluon predictor with selected model
-            if selected_model and selected_model != 'WeightedEnsemble_L3 (Best)':
-                # Clean model name
-                clean_model = selected_model.replace(' (Best)', '')
-                try:
-                    proba_result = self.predictor.predict_proba(car_data, model=clean_model)
-                    model_used = selected_model
-                except Exception as model_error:
-                    logger.warning(f"Failed to use specific model {clean_model}: {model_error}")
-                    proba_result = self.predictor.predict_proba(car_data)
-                    model_used = "WeightedEnsemble_L3 (fallback)"
-            else:
-                proba_result = self.predictor.predict_proba(car_data)
-                model_used = "WeightedEnsemble_L3 (Best)"
-            
-            # Convert to dict format and get top-k predictions
-            if hasattr(proba_result, 'iloc'):
-                proba_dict = proba_result.iloc[0].to_dict()
-            else:
-                proba_dict = dict(zip(self.trained_dealers, proba_result[0]))
-            
-            # Sort by probability and get top 5
-            sorted_dealers = sorted(proba_dict.items(), key=lambda x: x[1], reverse=True)[:5]
-            
-            # Format results
-            top_dealer = sorted_dealers[0][0]
-            confidence = f"{sorted_dealers[0][1]:.2%}"
-            
-            # Create detailed results
-            results_text = "🏆 **Top 5 Recommended Dealers:**\n\n"
-            for i, (dealer, prob) in enumerate(sorted_dealers, 1):
-                emoji = "🥇" if i == 1 else "🥈" if i == 2 else "🥉" if i == 3 else "🔸"
-                results_text += f"{emoji} **{i}. {dealer}** - {prob:.1%} confidence\n"
-            
-            # Add car summary
-            car_summary = f"""
-            
-**🚗 Vehicle Specifications:**
-• **Make & Model:** {make} {model} ({year})
-• **Body Type:** {body_type} • **Segment:** {segment}
-• **Engine:** {engine_size}L, {cylinders} cylinders, {power}HP
-• **Drivetrain:** {fuel_type} • {transmission} • {drive_type}
-• **Details:** {doors} doors, {seats} seats • {odometer:,} km
-• **Condition:** {condition} • **Safety:** {safety_rating}★
-
-**🤖 Model:** {model_used}
-            """
-            
-            return f"🎯 **Best Match: {top_dealer}**", confidence, results_text + car_summary
-            
-        except Exception as e:
-            logger.error(f"Prediction error: {e}")
-            return f"❌ Error making prediction: {str(e)}", "", ""
-
-    def _map_body_type_group(self, body_type):
-        """Map body type to group"""
-        if not body_type:
-            return 'Passenger'
-        body_lower = body_type.lower()
-        if body_lower in ['ute', 'truck', 'van']:
-            return 'Commercial'
-        return 'Passenger'
-
-    def _map_body_style(self, doors):
-        """Map doors to body style"""
-        if not doors:
-            return '4 Door'
-        doors = int(doors)
-        if doors == 2:
-            return '2 Door'
-        elif doors == 3:
-            return '3 Door'
-        elif doors == 5:
-            return '5 Door'
-        else:
-            return '4 Door'
-
-    def load_data_files(self):
-        """Load available CSV data files"""
-        try:
-            data_dir = "./data"
-            if os.path.exists(data_dir):
-                csv_files = glob.glob(os.path.join(data_dir, "*.csv"))
-                self.data_files = [os.path.basename(f) for f in csv_files]
-                logger.info(f"✅ Found {len(self.data_files)} CSV files: {self.data_files}")
-            else:
-                self.data_files = []
-                logger.warning("❌ Data directory not found")
-        except Exception as e:
-            logger.error(f"❌ Failed to load data files: {e}")
-            self.data_files = []
-
-    def search_data_files(self, make=None, model=None, year_min=None, year_max=None, 
-                         body_type=None, fuel_type=None, max_odometer=None, 
-                         max_price=None, selected_file=None, max_results=100, show_dealer_stats=True):
-        """Search through CSV data files using pandas filtering"""
-        try:
-            if not self.data_files:
-                return "❌ No CSV data files available", pd.DataFrame()
-            
-            # Use selected file or default to first available
-            if selected_file and selected_file in self.data_files:
-                file_to_search = selected_file
-            else:
-                file_to_search = self.data_files[0] if self.data_files else None
-            
-            if not file_to_search:
-                return "❌ No valid file selected", pd.DataFrame()
-            
-            file_path = os.path.join("./data", file_to_search)
-            
-            # Load the CSV file
-            logger.info(f"🔍 Loading data from: {file_to_search}")
-            
-            # Read CSV with error handling for different encodings
-            try:
-                df = pd.read_csv(file_path, encoding='utf-8')
-            except UnicodeDecodeError:
-                try:
-                    df = pd.read_csv(file_path, encoding='latin-1')
-                except:
-                    df = pd.read_csv(file_path, encoding='cp1252')
-            
-            # Convert column names to lowercase for easier matching
-            df.columns = df.columns.str.lower().str.strip()
-            
-            original_count = len(df)
-            
-            # Apply filters using correct column names from the dataset
-            if make and 'make' in df.columns:
-                df = df[df['make'].str.contains(make, case=False, na=False)]
-            
-            if model and 'model' in df.columns:
-                df = df[df['model'].str.contains(model, case=False, na=False)]
-            
-            if year_min and 'manu_year' in df.columns:
-                df = df[pd.to_numeric(df['manu_year'], errors='coerce') >= year_min]
-            
-            if year_max and 'manu_year' in df.columns:
-                df = df[pd.to_numeric(df['manu_year'], errors='coerce') <= year_max]
-            
-            if body_type and 'vehicle_body_type' in df.columns:
-                df = df[df['vehicle_body_type'].str.contains(body_type, case=False, na=False)]
-            
-            if fuel_type and 'vehicle_fuel_type' in df.columns:
-                df = df[df['vehicle_fuel_type'].str.contains(fuel_type, case=False, na=False)]
-            
-            if max_odometer and 'odometer' in df.columns:
-                df = df[pd.to_numeric(df['odometer'], errors='coerce') <= max_odometer]
-            
-            if max_price and 'advertised_price' in df.columns:
-                df = df[pd.to_numeric(df['advertised_price'], errors='coerce') <= max_price]
-            
-            filtered_count = len(df)
-            
-            if df.empty:
-                return f"✅ Searched {file_to_search} ({original_count:,} records) - No matches found", pd.DataFrame()
-            
-            # Create dealer ranking summary
-            if show_dealer_stats and 'dealer_trading_name' in df.columns:
-                dealer_summary = self._create_dealer_summary(df)
-                return f"✅ Found {filtered_count:,} matches from {original_count:,} records in {file_to_search}", dealer_summary
-            else:
-                # Return basic summary without dealer rankings
-                summary_df = pd.DataFrame({
-                    'Total Matches': [filtered_count],
-                    'File Searched': [file_to_search]
-                })
-                return f"✅ Found {filtered_count:,} matches from {original_count:,} records in {file_to_search}", summary_df
-                
-        except Exception as e:
-            logger.error(f"❌ Search error: {e}")
-            return f"❌ Error searching data: {str(e)}", pd.DataFrame()
-
-    def _create_dealer_summary(self, df):
-        """Create dealer ranking summary showing top dealers by car count"""
-        try:
-            logger.info(f"📊 Creating dealer summary from {len(df)} matching cars...")
-            
-            # Count cars per dealer
-            dealer_counts = df['dealer_trading_name'].value_counts()
-            
-            # Get top 5 dealers
-            top_dealers = dealer_counts.head(5)
-            
-            # Create summary dataframe
-            summary_data = []
-            for rank, (dealer_name, car_count) in enumerate(top_dealers.items(), 1):
-                summary_data.append({
-                    'Rank': f"#{rank}",
-                    'Dealer Name': dealer_name,
-                    'Matching Cars': car_count
-                })
-            
-            summary_df = pd.DataFrame(summary_data)
-            
-            logger.info(f"✅ Created dealer summary. Top dealer: {top_dealers.index[0]} with {top_dealers.iloc[0]} cars")
-            return summary_df
-            
-        except Exception as e:
-            logger.error(f"❌ Error creating dealer summary: {e}")
-            return pd.DataFrame({'Error': ['Failed to create dealer summary']})
-
-# Initialize the matcher with local model
-matcher = CarDealerMatcher(model_path="./autogluon_model")
-
-# Initialize a separate simple matcher for the simple tab
-simple_matcher = CarDealerMatcher(model_path="./simple_autogluon_models")
-
-# Define structured make-model data for dynamic dropdowns
-MAKE_MODEL_DATA = {
-    "Toyota": [
-        "Camry",
-        "Corolla",
-        "HiAce",
-        "Hilux",
-        "Kluger",
-        "Landcruiser",
-        "Landcruiser Prado",
-        "Prius V",
-        "RAV4",
-        "Yaris",
-        "Yaris Cross"
-    ],
-    "Audi": [
-        "Q3",
-        "SQ7",
-        "TT"
-    ],
-    "BMW": [
-        "125I",
-        "5",
-        "M2"
-    ],
-    "Fiat": [
-        "500",
-        "500C",
-        "Ducato"
-    ],
-    "Ford": [
-        "Everest",
-        "F150",
-        "Falcon",
-        "Fiesta",
-        "Ranger",
-        "Territory"
-    ],
-    "GWM": [
-        "Haval H6"
-    ],
-    "Great Wall": [
-        "Steed"
-    ],
-    "Holden": [
-        "Calais",
-        "Captiva",
-        "Colorado",
-        "Colorado 7",
-        "Commodore",
-        "Cruze",
-        "Trax",
-        "UTE"
-    ],
-    "Honda": [
-        "CR-V"
-    ],
-    "Hyundai": [
-        "Accent",
-        "Elantra",
-        "I30",
-        "IX35",
-        "Iload",
-        "Kona",
-        "Santa FE",
-        "Tucson",
-        "Veloster"
-    ],
-    "Isuzu": [
-        "D-MAX"
-    ],
-    "Jaguar": [
-        "E-Pace"
-    ],
-    "Jeep": [
-        "Grand Cherokee"
-    ],
-    "Kia": [
-        "Cerato",
-        "Optima",
-        "Sorento",
-        "Sportage"
-    ],
-    "LDV": [
-        "D90",
-        "Deliver 9"
-    ],
-    "Land Rover": [
-        "Discovery Sport"
-    ],
-    "MG": [
-        "MG3 Auto"
-    ],
-    "Mazda": [
-        "3",
-        "6",
-        "BT-50",
-        "CX-3",
-        "CX-30",
-        "CX-5",
-        "CX-9",
-        "MX-5"
-    ],
-    "Mercedes-Benz": [
-        "C180",
-        "C250",
-        "E350",
-        "EQS",
-        "GL320",
-        "GLC250",
-        "SL400",
-        "Sprinter"
-    ],
-    "Mini": [
-        "3D Hatch"
-    ],
-    "Mitsubishi": [
-        "ASX",
-        "Eclipse Cross",
-        "Lancer",
-        "Outlander",
-        "Pajero Sport",
-        "Triton"
-    ],
-    "Nissan": [
-        "Maxima",
-        "Navara",
-        "Pathfinder",
-        "Patrol",
-        "Qashqai",
-        "Skyline",
-        "X-Trail"
-    ],
-    "Porsche": [
-        "Cayenne",
-        "Macan"
-    ],
-    "Renault": [
-        "Captur",
-        "Megane"
-    ],
-    "Skoda": [
-        "Octavia"
-    ],
-    "Subaru": [
-        "Forester",
-        "Impreza",
-        "Liberty",
-        "XV"
-    ],
-    "Suzuki": [
-        "Jimny",
-        "Swift"
-    ],
-    "Volkswagen": [
-        "Amarok",
-        "Golf",
-        "Polo",
-        "T-ROC",
-        "Tiguan"
-    ],
-    "Volvo": [
-        "XC40",
-        "XC60"
-    ]
-}
-
-# Extract makes list for dropdown
-CAR_MAKES = list(MAKE_MODEL_DATA.keys())
-
-# Define other dropdown options
-BODY_TYPES = ['Sedan', 'Hatchback', 'SUV', 'Wagon', 'Convertible', 'Coupe', 'Ute', 'Van']
-FUEL_TYPES = ['Petrol', 'Diesel', 'Hybrid', 'Electric', 'LPG']
-TRANSMISSION_TYPES = ['Automatic', 'Manual', 'CVT']
-DRIVE_TYPES = ['Front Wheel Drive', 'Rear Wheel Drive', 'All Wheel Drive', '4x4']
-SEGMENTS = ['Light', 'Small', 'Medium', 'Large', 'Upper Large', 'Luxury', 'Sports']
-CONDITIONS = ['New', 'Used', 'Demo']
-
-def update_models(make):
-    """Update model choices based on selected make"""
-    if make in MAKE_MODEL_DATA:
-        models = MAKE_MODEL_DATA[make]
-        return gr.Dropdown(choices=models, value=models[0] if models else None)
-    else:
-        return gr.Dropdown(choices=[], value=None)
-
-def predict_dealers_interface(make, model, year, body_type, fuel_type, transmission, 
-                            odometer, doors, seats, engine_size, power, cylinders,
-                            safety_rating, drive_type, segment, condition, selected_model):
-    """Interface function for Gradio"""
-    return matcher.predict_dealers(make, model, year, body_type, fuel_type, transmission,
-                                 odometer, doors, seats, engine_size, power, cylinders,
-                                 safety_rating, drive_type, segment, condition, selected_model)
-
-def search_data_interface(make, model, year_min, year_max, body_type, fuel_type, 
-                         max_odometer, max_price, selected_file, max_results, show_dealer_stats):
-    """Interface function for traditional data search"""
-    message, result_df = matcher.search_data_files(make, model, year_min, year_max,
-                                                   body_type, fuel_type, max_odometer,
-                                                   max_price, selected_file, max_results, show_dealer_stats)
-    
-    if result_df.empty:
-        return message, "No results to display", ""
-    else:
-        if show_dealer_stats and 'Rank' in result_df.columns:
-            # Dealer summary results
-            total_dealers = len(result_df)
-            total_cars = result_df['Matching Cars'].sum() if 'Matching Cars' in result_df.columns else 0
-            
-            info_text = f"**🏆 Top {total_dealers} Dealers** | **📊 Total Matching Cars:** {total_cars:,}\n\n"
-            
-            if total_dealers > 0:
-                top_dealer = result_df.iloc[0]
-                info_text += f"**👑 Leading Dealer:** {top_dealer['Dealer Name']} with {top_dealer['Matching Cars']} cars\n\n"
-        else:
-            # Basic search results
-            info_text = f"**📊 Search completed successfully**\n\n"
+        # App header
+        gr.Markdown(get_app_header())
+        gr.Markdown(get_app_description())
         
-        # Convert DataFrame to HTML table for better display
-        html_table = result_df.to_html(classes='table table-striped', 
-                                      table_id='dealer-summary', escape=False, index=False)
+        # Create tabs
+        with gr.Tabs():
+            simple_tab = create_simple_tab(simple_matcher)
+            detailed_tab = create_detailed_tab(matcher)
+            traditional_tab = create_traditional_tab(matcher)
+            simple_search_tab = create_simple_search_tab(matcher)
         
-        return message, info_text, html_table
-
-# Create the modern Gradio interface
-with gr.Blocks(
-    title="🚗 Swiper Match - Car Dealer Predictor", 
-    theme=gr.themes.Default(),
-    css="""
-    .gradio-container {
-        max-width: 1200px !important;
-        margin: 0 auto !important;
-    }
-    """
-) as demo:
-    
-    gr.Markdown("""
-    # 🚗 Swiper Match - Car Dealer Predictor
-    ### AI-Powered Dealer Matching Based on Vehicle Specifications
-    Find the perfect dealer for your dream car using machine learning
-    """)
-    
-    gr.Markdown("""
-    **🎯 How it works:** This tool analyzes vehicle specifications to predict which dealers are most likely to have cars matching your preferences. The model focuses on technical specifications, not pricing.
-    """)
-    
-    with gr.Tabs():
-        # Simple Tab
-        with gr.Tab("🔍 Simple"):
-            gr.Markdown("### Quick Car Dealer Search")
-            gr.Markdown("Enter just the basic details for a quick recommendation")
-            
-            # Model Selection for Simple Tab
-            simple_model_selection = gr.Dropdown(
-                choices=simple_matcher.available_models if simple_matcher.model_loaded else ['Model not loaded'],
-                label="🤖 Select AI Model",
-                value=simple_matcher.available_models[0] if simple_matcher.available_models else 'Model not loaded',
-                info="WeightedEnsemble_L3 provides the best overall performance"
-            )
-            
-            with gr.Row():
-                # Basic inputs
-                with gr.Column(scale=1):
-                    simple_make = gr.Dropdown(choices=CAR_MAKES, label="Make", value="Toyota")
-                    simple_model = gr.Dropdown(choices=MAKE_MODEL_DATA["Toyota"], label="Model", value="Camry")
-                    
-                with gr.Column(scale=1):
-                    simple_year = gr.Number(label="Year", value=2020, minimum=1990, maximum=2025)
-                    simple_odometer = gr.Number(label="Odometer (km)", value=50000, minimum=0)
-            
-            # Simple prediction button
-            simple_predict_btn = gr.Button(
-                "🎯 Find Best Dealers (Simple)",
-                variant="primary",
-                size="lg"
-            )
-            
-            # Simple Results Section
-            with gr.Row():
-                with gr.Column(scale=1):
-                    simple_top_dealer = gr.Textbox(
-                        label="🏆 Top Recommended Dealer",
-                        interactive=False,
-                        lines=2
-                    )
-                    simple_confidence = gr.Textbox(
-                        label="🎯 Confidence Score",
-                        interactive=False,
-                        lines=1
-                    )
-                with gr.Column(scale=2):
-                    simple_detailed_results = gr.Markdown(
-                        label="📊 Results",
-                        value="Click 'Find Best Dealers (Simple)' to see recommendations..."
-                    )
+        # Model Information Footer
+        gr.Markdown("---")
+        gr.Markdown(get_model_status_info(matcher, simple_matcher))
         
-        # Detailed Tab 
-        with gr.Tab("⚙️ Detailed"):
-            gr.Markdown("### Advanced Car Dealer Search")
-            gr.Markdown("Specify detailed vehicle characteristics for more precise recommendations")
-            
-            # Model Selection Section
-            with gr.Row():
-                model_selection = gr.Dropdown(
-                    choices=matcher.available_models if matcher.model_loaded else ['Model not loaded'],
-                    label="🤖 Select AI Model",
-                    value=matcher.available_models[0] if matcher.available_models else 'Model not loaded',
-                    info="WeightedEnsemble_L3 provides the best overall performance",
-                    scale=2
-                )
-                
-                with gr.Column(scale=1):
-                    gr.Markdown("""
-                    **Available Models:**
-                    - **WeightedEnsemble**: Best performance (combines all models)
-                    - **RandomForest**: Tree-based, interpretable
-                    - **XGBoost**: Gradient boosting, fast
-                    - **NeuralNet**: Deep learning, complex patterns
-                    """)
-            
-            with gr.Row():
-                # Basic Vehicle Info
-                with gr.Column(scale=1):
-                    gr.Markdown("### 🚗 Basic Vehicle Information")
-                    
-                    make = gr.Dropdown(choices=CAR_MAKES, label="Make", value="Toyota")
-                    model = gr.Dropdown(choices=MAKE_MODEL_DATA["Toyota"], label="Model", value="Camry")
-                    year = gr.Number(label="Year", value=2020, minimum=1990, maximum=2025)
-                    condition = gr.Dropdown(choices=CONDITIONS, label="Condition", value="Used")
-                    
-                # Body & Style
-                with gr.Column(scale=1):
-                    gr.Markdown("### 🏗️ Body & Style")
-                    
-                    body_type = gr.Dropdown(choices=BODY_TYPES, label="Body Type", value="Sedan")
-                    segment = gr.Dropdown(choices=SEGMENTS, label="Vehicle Segment", value="Medium")
-                    doors = gr.Number(label="Doors", value=4, minimum=2, maximum=6)
-                    seats = gr.Number(label="Seats", value=5, minimum=2, maximum=9)
-                    
-                # Engine & Performance  
-                with gr.Column(scale=1):
-                    gr.Markdown("### ⚡ Engine & Performance")
-                    
-                    fuel_type = gr.Dropdown(choices=FUEL_TYPES, label="Fuel Type", value="Petrol")
-                    transmission = gr.Dropdown(choices=TRANSMISSION_TYPES, label="Transmission", value="Automatic")
-                    engine_size = gr.Number(label="Engine Size (L)", value=2.0, minimum=0.5, maximum=8.0)
-                    cylinders = gr.Number(label="Cylinders", value=4, minimum=2, maximum=12)
-            
-            with gr.Row():
-                # Technical Details
-                with gr.Column(scale=1):
-                    gr.Markdown("### 🔧 Technical Details")
-                    
-                    power = gr.Number(label="Power (HP)", value=150, minimum=50, maximum=1000)
-                    drive_type = gr.Dropdown(choices=DRIVE_TYPES, label="Drive Type", value="Front Wheel Drive")
-                    safety_rating = gr.Number(label="Safety Rating (1-5)", value=5, minimum=1, maximum=5)
-                    
-                # Usage & History
-                with gr.Column(scale=1):
-                    gr.Markdown("### 📊 Usage & History")
-                    
-                    odometer = gr.Number(label="Odometer (km)", value=50000, minimum=0)
-                    
-            # Detailed prediction button
-            predict_btn = gr.Button(
-                "🎯 Find Best Dealers (Detailed)",
-                variant="primary",
-                size="lg"
-            )
-            
-            # Detailed Results Section
-            with gr.Row():
-                with gr.Column(scale=1):
-                    top_dealer = gr.Textbox(
-                        label="🏆 Top Recommended Dealer",
-                        interactive=False,
-                        lines=2
-                    )
-                    confidence = gr.Textbox(
-                        label="🎯 Confidence Score",
-                        interactive=False,
-                        lines=1
-                    )
-                with gr.Column(scale=2):
-                    detailed_results = gr.Markdown(
-                        label="📊 Detailed Results",
-                        value="Click 'Find Best Dealers (Detailed)' to see AI recommendations..."
-                    )
+        # Setup event handlers
+        interface_functions = {
+            'update_models': update_models,
+            'predict': predict_dealers_interface,
+            'simple_predict': simple_predict_dealers_interface,
+            'search': search_data_interface,
+            'simple_search': simple_search_data_interface
+        }
         
-        # Traditional Search Tab
-        with gr.Tab("📊 Traditional Search"):
-            gr.Markdown("### CSV Data File Search")
-            gr.Markdown("Search through car listing CSV files and rank dealers by inventory size")
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### 🗂️ File Selection")
-                    selected_file = gr.Dropdown(
-                        choices=matcher.data_files,
-                        label="Select CSV File",
-                        value=matcher.data_files[0] if matcher.data_files else None,
-                        info=f"Available files: {len(matcher.data_files)}"
-                    )
-                    
-                    max_results = gr.Number(
-                        label="Max Results",
-                        value=100,
-                        minimum=1,
-                        maximum=1000,
-                        info="Limit number of results returned"
-                    )
-                    
-                    show_dealer_stats = gr.Checkbox(
-                        label="📊 Show Dealer Rankings",
-                        value=True,
-                        info="Rank dealers by number of matching cars"
-                    )
-                
-                with gr.Column(scale=2):
-                    gr.Markdown("### 🔍 Search Filters")
-                    
-                    with gr.Row():
-                        search_make = gr.Textbox(
-                            label="Make (contains)",
-                            placeholder="e.g., Toyota, Ford",
-                            info="Search for car manufacturer"
-                        )
-                        search_model = gr.Textbox(
-                            label="Model (contains)",
-                            placeholder="e.g., Camry, Focus",
-                            info="Search for car model"
-                        )
-                    
-                    with gr.Row():
-                        year_min = gr.Number(
-                            label="Year (Min)",
-                            value=2015,
-                            minimum=1980,
-                            maximum=2025,
-                            info="Minimum manufacturing year"
-                        )
-                        year_max = gr.Number(
-                            label="Year (Max)",
-                            value=2024,
-                            minimum=1980,
-                            maximum=2025,
-                            info="Maximum manufacturing year"
-                        )
-                    
-                    with gr.Row():
-                        search_body_type = gr.Textbox(
-                            label="Body Type (contains)",
-                            placeholder="e.g., sedan, suv, hatch",
-                            info="Vehicle body style"
-                        )
-                        search_fuel_type = gr.Textbox(
-                            label="Fuel Type (contains)",
-                            placeholder="e.g., petrol, diesel, electric",
-                            info="Fuel/energy type"
-                        )
-                    
-                    with gr.Row():
-                        max_odometer = gr.Number(
-                            label="Max Odometer (km)",
-                            minimum=0,
-                            info="Maximum mileage"
-                        )
-                        max_price = gr.Number(
-                            label="Max Price (AUD)",
-                            minimum=0,
-                            info="Maximum advertised price"
-                        )
-            
-            # Traditional search button
-            search_btn = gr.Button(
-                "🔍 Search CSV Data",
-                variant="primary",
-                size="lg"
-            )
-            
-            # Traditional Search Results Section
-            with gr.Row():
-                search_status = gr.Textbox(
-                    label="🔍 Search Status",
-                    interactive=False,
-                    lines=2
-                )
-            
-            with gr.Row():
-                search_info = gr.Markdown(
-                    label="📊 Results Info",
-                    value="Click 'Search CSV Data' to start searching..."
-                )
-            
-            with gr.Row():
-                search_results_table = gr.HTML(
-                    label="📋 Search Results",
-                    value="<p>No search performed yet</p>"
-                )
-            
-            # Data file info section
-            gr.Markdown(f"""
-            ---
-            ### 📁 Available Data Files
-            
-            **Files Found:** {len(matcher.data_files)}
-            
-            **File List:**
-            {chr(10).join([f'• {file}' for file in matcher.data_files]) if matcher.data_files else '• No CSV files found in ./data directory'}
-            
-            ### 🔍 Search Features
-            
-            **📊 Dealer Ranking:** Dealers ranked by number of cars matching your criteria
-            **🏆 Inventory Priority:** Dealers with more matching inventory appear first
-            **📈 Column Mapping:** Uses actual dataset columns:
-            - **Make/Model:** `make`, `model`
-            - **Year:** `manu_year` (manufacturing year)
-            - **Body Type:** `vehicle_body_type`
-            - **Fuel Type:** `vehicle_fuel_type`
-            - **Transmission:** `vehicle_transmission_type`
-            - **Mileage:** `odometer`
-            - **Price:** `advertised_price`
-            - **Dealer:** `dealer_trading_name`
-            - **Location:** `dealer_city`, `dealer_state`
-            
-            ### 📊 Dealer Ranking System
-            
-            **How it works:** Counts how many cars each dealer has that match your search criteria
-            **Ranking Logic:** Dealers with more matching cars get better ranks (Rank 1 = most inventory)
-            **Sorting:** Results sorted by dealer inventory count first, then by price
-            **Performance:** Fast counting using pandas group operations
-            """)
-    
-    # Model Information Footer
-    detailed_status_emoji = "✅" if matcher.model_loaded else "❌"
-    simple_status_emoji = "✅" if simple_matcher.model_loaded else "❌"
-    
-    gr.Markdown(f"""
-    ---
-    ### 📊 Model Information
-    
-    #### 🔧 **Detailed Model** (Advanced Search)
-    **Status:** {detailed_status_emoji} {"Model Loaded Successfully" if matcher.model_loaded else "Model Not Available"}  
-    **Path:** ./autogluon_model  
-    **Trained Dealers:** {len(matcher.trained_dealers) if matcher.model_loaded else "N/A"}  
-    **Available Models:** {len(matcher.available_models) if matcher.model_loaded else "N/A"} ({', '.join(matcher.available_models[:3]) + ('...' if len(matcher.available_models) > 3 else '') if matcher.model_loaded and matcher.available_models else "N/A"})  
-    **Features:** 23 vehicle specifications (no pricing data)  
-    
-    #### 🔍 **Simple Model** (Quick Search)  
-    **Status:** {simple_status_emoji} {"Model Loaded Successfully" if simple_matcher.model_loaded else "Model Not Available"}  
-    **Path:** ./simple_autogluon_models  
-    **Trained Dealers:** {len(simple_matcher.trained_dealers) if simple_matcher.model_loaded else "N/A"}  
-    **Available Models:** {len(simple_matcher.available_models) if simple_matcher.model_loaded else "N/A"} ({', '.join(simple_matcher.available_models[:3]) + ('...' if len(simple_matcher.available_models) > 3 else '') if simple_matcher.model_loaded and simple_matcher.available_models else "N/A"})  
-    **Features:** Subset of vehicle specifications for faster inference  
-    
-    #### 🤖 **Architecture**
-    **Framework:** AutoGluon TabularPredictor  
-    **Ensemble Learning:** Multiple algorithms combined via weighted voting  
-    **Algorithms:** RandomForest, XGBoost, NeuralNetTorch, CatBoost, LightGBM  
-    **Task:** Multi-class classification for dealer prediction
-    """)
-    
-    # Set up the prediction functions
-    
-    # Simple prediction function (with default values for missing inputs)
-    def simple_predict_dealers_interface(simple_make, simple_model, simple_year, simple_odometer, simple_model_selection):
-        """Simple interface function for Gradio with conditional parameters"""
+        tabs_data = (simple_tab, detailed_tab, traditional_tab, simple_search_tab)
+        matchers = (matcher, simple_matcher)
         
-        return simple_matcher.predict_dealers(
-            make=simple_make, 
-            model=simple_model, 
-            year=simple_year, 
-            body_type=None,
-            fuel_type=None,
-            transmission=None,
-            odometer=simple_odometer, 
-            doors=None,
-            seats=None,
-            engine_size=None,
-            power=None,
-            cylinders=None,
-            safety_rating=None,
-            drive_type=None,
-            segment=None,
-            condition=None,
-            selected_model=simple_model_selection
-        )
-    
-    # Simple tab click event"
-    simple_predict_btn.click(
-        fn=simple_predict_dealers_interface,
-        inputs=[simple_make, simple_model, simple_year, simple_odometer, simple_model_selection],
-        outputs=[simple_top_dealer, simple_confidence, simple_detailed_results]
-    )
+        setup_event_handlers(tabs_data, interface_functions, matchers)
     
-    # Detailed tab click event
-    predict_btn.click(
-        fn=predict_dealers_interface,
-        inputs=[make, model, year, body_type, fuel_type, transmission, 
-               odometer, doors, seats, engine_size, power, cylinders,
-               safety_rating, drive_type, segment, condition, model_selection],
-        outputs=[top_dealer, confidence, detailed_results]
-    )
-    
-    # Traditional search click event
-    search_btn.click(
-        fn=search_data_interface,
-        inputs=[search_make, search_model, year_min, year_max, search_body_type, 
-               search_fuel_type, max_odometer, max_price, selected_file, max_results, show_dealer_stats],
-        outputs=[search_status, search_info, search_results_table]
-    )
-    
-    # Set up dynamic model updating based on make selection
-    simple_make.change(
-        fn=update_models,
-        inputs=simple_make,
-        outputs=simple_model
-    )
-    
-    make.change(
-        fn=update_models,
-        inputs=make,
-        outputs=model
-    )
+    return demo
+
 
 # Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    logger.info("🎯 Starting Swiper Match application...")
+    demo = create_app()
+    demo.launch() 

app_new.py

@@ -0,0 +1,82 @@
+"""
+Swiper Match - Car Dealer Predictor
+Main application file using modular components
+"""
+
+import gradio as gr
+import logging
+
+# Import core modules
+from core.matcher import CarDealerMatcher
+from core.config import DETAILED_MODEL_PATH, SIMPLE_MODEL_PATH, UI_CONFIG, GRADIO_CSS
+
+# Import UI components
+from ui.interface import (
+    update_models, predict_dealers_interface, simple_predict_dealers_interface,
+    search_data_interface, simple_search_data_interface
+)
+from ui.tabs.simple_tab import create_simple_tab
+from ui.tabs.detailed_tab import create_detailed_tab
+from ui.tabs.traditional_tab import create_traditional_tab
+from ui.tabs.simple_search_tab import create_simple_search_tab
+
+# Import utilities
+from utils.helpers import get_model_status_info, get_app_header, get_app_description, setup_event_handlers
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def create_app():
+    """Create and configure the Gradio application"""
+    
+    # Initialize the matchers
+    logger.info("🚀 Initializing Car Dealer Matchers...")
+    matcher = CarDealerMatcher(model_path=DETAILED_MODEL_PATH)
+    simple_matcher = CarDealerMatcher(model_path=SIMPLE_MODEL_PATH)
+    
+    # Create the Gradio interface
+    with gr.Blocks(
+        title=UI_CONFIG['title'], 
+        theme=gr.themes.Default(),
+        css=GRADIO_CSS
+    ) as demo:
+        
+        # App header
+        gr.Markdown(get_app_header())
+        gr.Markdown(get_app_description())
+        
+        # Create tabs
+        with gr.Tabs():
+            simple_tab = create_simple_tab(simple_matcher)
+            detailed_tab = create_detailed_tab(matcher)
+            traditional_tab = create_traditional_tab(matcher)
+            simple_search_tab = create_simple_search_tab(matcher)
+        
+        # Model Information Footer
+        gr.Markdown("---")
+        gr.Markdown(get_model_status_info(matcher, simple_matcher))
+        
+        # Setup event handlers
+        interface_functions = {
+            'update_models': update_models,
+            'predict': predict_dealers_interface,
+            'simple_predict': simple_predict_dealers_interface,
+            'search': search_data_interface,
+            'simple_search': simple_search_data_interface
+        }
+        
+        tabs_data = (simple_tab, detailed_tab, traditional_tab, simple_search_tab)
+        matchers = (matcher, simple_matcher)
+        
+        setup_event_handlers(tabs_data, interface_functions, matchers)
+    
+    return demo
+
+
+# Launch the app
+if __name__ == "__main__":
+    logger.info("🎯 Starting Swiper Match application...")
+    demo = create_app()
+    demo.launch() 

app_original.py

@@ -0,0 +1,1250 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import os
+import logging
+from huggingface_hub import snapshot_download
+import glob
+
+# Hugging Face configuration
+#print(os.getenv('HF_TOKEN'))
+HF_REPO_ID = "mzx/Swiper-Match"  # Replace with your actual repo ID
+HF_TOKEN = os.getenv('HF_TOKEN')  # Will be set when provided by user
+
+# AutoGluon imports
+from autogluon.tabular import TabularPredictor
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class CarDealerMatcher:
+    def __init__(self, model_path: str = "./autogluon_model"):
+        self.model_path = model_path
+        self.predictor = None
+        self.trained_dealers = []
+        self.available_models = []
+        self.model_loaded = False
+        self.data_files = []
+        self.load_model()
+        self.load_data_files()
+    
+    def load_model(self):
+        """Load AutoGluon model from local directory or download from Hugging Face"""
+        try:
+            logger.info(f"🤖 Loading AutoGluon model from: {self.model_path}")
+            
+            # Check if model exists locally
+            if not os.path.exists(self.model_path):
+                logger.info(f"📥 Model not found locally. Downloading from Hugging Face: {HF_REPO_ID}")
+                try:
+                    # Download the model from Hugging Face
+                    downloaded_path = snapshot_download(
+                        repo_id=HF_REPO_ID,
+                        cache_dir="./hf_cache",
+                        token=HF_TOKEN,
+                        #allow_patterns=["autogluon_model/**"],
+                        local_dir="./",
+                        local_dir_use_symlinks=False
+                    )
+                    logger.info(f"✅ Model downloaded successfully to: {downloaded_path}")
+                except Exception as download_error:
+                    logger.error(f"❌ Failed to download model from Hugging Face: {download_error}")
+                    self.model_loaded = False
+                    return
+            
+            # Load the model
+            if os.path.exists(self.model_path):
+                self.predictor = TabularPredictor.load(self.model_path)
+                self._extract_trained_dealers()
+                self._extract_available_models()
+                self.model_loaded = True
+                logger.info(f"✅ Model loaded successfully! Can predict for {len(self.trained_dealers)} dealers")
+                logger.info(f"🎯 Available models: {self.available_models}")
+            else:
+                logger.error(f"❌ Model directory still not found after download attempt: {self.model_path}")
+                self.model_loaded = False
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to load model: {e}")
+            self.model_loaded = False
+    
+    def _extract_trained_dealers(self):
+        """Extract trained dealers from the predictor"""
+        try:
+            if hasattr(self.predictor, 'class_labels'):
+                self.trained_dealers = list(self.predictor.class_labels)
+            else:
+                # Use a dummy prediction to extract dealer names
+                dummy_data = self._create_dummy_data()
+                proba_result = self.predictor.predict_proba(dummy_data)
+                if hasattr(proba_result, 'columns'):
+                    self.trained_dealers = list(proba_result.columns)
+                else:
+                    self.trained_dealers = ['Model loaded successfully']
+        except Exception as e:
+            self.trained_dealers = ['Model loaded successfully']
+            logger.warning(f"Could not extract dealer list: {e}")
+    
+    def _extract_available_models(self):
+        """Extract available models from the predictor"""
+        try:
+            if hasattr(self.predictor, 'model_names'):
+                raw_models = self.predictor.model_names()
+                print("my models", raw_models)
+                # Add ensemble options with user-friendly names
+                self.available_models = ['WeightedEnsemble_L3 (Best)', 'WeightedEnsemble_L2'] + [
+                    name for name in raw_models if 'WeightedEnsemble' not in name
+                ]
+         
+        except Exception as e:
+            self.available_models = ['WeightedEnsemble_L3 (Best)']
+            logger.warning(f"Could not extract model list: {e}")
+
+    def _create_dummy_data(self):
+        """Create dummy data with all required features"""
+        return pd.DataFrame([{
+            'make': 'toyota',
+            'model': 'camry',
+            'year': 2020,
+            'car_age': 4,  # Add the missing car_age feature (2024 - 2020 = 4)
+            'vehicle_body_type': 'sedan',
+            'vehicle_fuel_type': 'petrol',
+            'vehicle_transmission_type': 'automatic',
+            'odometer': 50000,
+            'vehicle_doors': 4,
+            'vehicle_seats': 5,
+            'series': 'unknown',
+            'variant': 'unknown',
+            'vehicle_body_type_group': 'Passenger',
+            'vehicle_body_type_style': '4 Door',
+            'vehicle_cylinder_description': '4 Cylinder',
+            'vehicle_cylinders': 4.0,
+            'vehicle_drive_type': 'Front Wheel Drive',
+            'vehicle_engine_size': 2.0,
+            'vehicle_power': 150.0,
+            'vehicle_safety_rating': 5,
+            'vehicle_segment': 'Medium',
+            'condition': 'Used',
+            'vehicle_type': 1
+        }])
+
+    def predict_dealers(self, make=None, model=None, year=None, body_type=None, fuel_type=None, transmission=None, 
+                       odometer=None, doors=None, seats=None, engine_size=None, power=None, cylinders=None, 
+                       safety_rating=None, drive_type=None, segment=None, condition=None, selected_model=None):
+        """Predict top dealers for the given car specifications using selected model"""
+        
+        if not self.model_loaded:
+            return "❌ AutoGluon model not loaded. Please check model directory availability.", "", ""
+        
+        try:
+            # Calculate car age (current year - vehicle year)
+            current_year = 2024  # You can use datetime.now().year for dynamic year
+            car_age = current_year - int(year) if year else None
+            
+            # Create input dataframe with only non-None values for AutoGluon model
+            car_data_dict = {}
+            
+            # Add parameters only if they are not None
+            if make is not None:
+                car_data_dict['make'] = make.lower()
+            if model is not None:
+                car_data_dict['model'] = model.lower()
+            if year is not None:
+                car_data_dict['year'] = int(year)
+            if car_age is not None:
+                car_data_dict['car_age'] = car_age
+            if body_type is not None:
+                car_data_dict['vehicle_body_type'] = body_type.lower()
+            if fuel_type is not None:
+                car_data_dict['vehicle_fuel_type'] = fuel_type.lower()
+            if transmission is not None:
+                car_data_dict['vehicle_transmission_type'] = transmission.lower()
+            if odometer is not None:
+                car_data_dict['odometer'] = int(odometer)
+            if doors is not None:
+                car_data_dict['vehicle_doors'] = float(doors)
+            if seats is not None:
+                car_data_dict['vehicle_seats'] = float(seats)
+            if engine_size is not None:
+                car_data_dict['vehicle_engine_size'] = float(engine_size)
+            if power is not None:
+                car_data_dict['vehicle_power'] = float(power)
+            if cylinders is not None:
+                car_data_dict['vehicle_cylinders'] = float(cylinders)
+            if safety_rating is not None:
+                car_data_dict['vehicle_safety_rating'] = float(safety_rating)
+            if drive_type is not None:
+                car_data_dict['vehicle_drive_type'] = drive_type
+            if segment is not None:
+                car_data_dict['vehicle_segment'] = segment
+            if condition is not None:
+                car_data_dict['condition'] = condition
+                
+            # Auto-generated features based on inputs (only if base inputs exist)
+            if body_type is not None:
+                car_data_dict['vehicle_body_type_group'] = self._map_body_type_group(body_type)
+            if doors is not None:
+                car_data_dict['vehicle_body_type_style'] = self._map_body_style(doors)
+            if cylinders is not None:
+                car_data_dict['vehicle_cylinder_description'] = f'{int(cylinders)} Cylinder'
+                
+            # Always include these if not specified (required for model compatibility)
+            if 'series' not in car_data_dict:
+                car_data_dict['series'] = 'unknown'
+            if 'variant' not in car_data_dict:
+                car_data_dict['variant'] = 'unknown'
+            if 'vehicle_type' not in car_data_dict:
+                car_data_dict['vehicle_type'] = 1  # Passenger vehicle
+            
+            car_data = pd.DataFrame([car_data_dict])
+            
+            # Get predictions using AutoGluon predictor with selected model
+            if selected_model and selected_model != 'WeightedEnsemble_L3 (Best)':
+                # Clean model name
+                clean_model = selected_model.replace(' (Best)', '')
+                try:
+                    proba_result = self.predictor.predict_proba(car_data, model=clean_model)
+                    model_used = selected_model
+                except Exception as model_error:
+                    logger.warning(f"Failed to use specific model {clean_model}: {model_error}")
+                    proba_result = self.predictor.predict_proba(car_data)
+                    model_used = "WeightedEnsemble_L3 (fallback)"
+            else:
+                proba_result = self.predictor.predict_proba(car_data)
+                model_used = "WeightedEnsemble_L3 (Best)"
+            
+            # Convert to dict format and get top-k predictions
+            if hasattr(proba_result, 'iloc'):
+                proba_dict = proba_result.iloc[0].to_dict()
+            else:
+                proba_dict = dict(zip(self.trained_dealers, proba_result[0]))
+            
+            # Sort by probability and get top 5
+            sorted_dealers = sorted(proba_dict.items(), key=lambda x: x[1], reverse=True)[:5]
+            
+            # Format results
+            top_dealer = sorted_dealers[0][0]
+            confidence = f"{sorted_dealers[0][1]:.2%}"
+            
+            # Create detailed results
+            results_text = "🏆 **Top 5 Recommended Dealers:**\n\n"
+            for i, (dealer, prob) in enumerate(sorted_dealers, 1):
+                emoji = "🥇" if i == 1 else "🥈" if i == 2 else "🥉" if i == 3 else "🔸"
+                results_text += f"{emoji} **{i}. {dealer}** - {prob:.1%} confidence\n"
+            
+            # Add car summary
+            car_summary = f"""
+            
+**🚗 Vehicle Specifications:**
+• **Make & Model:** {make} {model} ({year})
+• **Body Type:** {body_type} • **Segment:** {segment}
+• **Engine:** {engine_size}L, {cylinders} cylinders, {power}HP
+• **Drivetrain:** {fuel_type} • {transmission} • {drive_type}
+• **Details:** {doors} doors, {seats} seats • {odometer:,} km
+• **Condition:** {condition} • **Safety:** {safety_rating}★
+
+**🤖 Model:** {model_used}
+            """
+            
+            return f"🎯 **Best Match: {top_dealer}**", confidence, results_text + car_summary
+            
+        except Exception as e:
+            logger.error(f"Prediction error: {e}")
+            return f"❌ Error making prediction: {str(e)}", "", ""
+
+    def _map_body_type_group(self, body_type):
+        """Map body type to group"""
+        if not body_type:
+            return 'Passenger'
+        body_lower = body_type.lower()
+        if body_lower in ['ute', 'truck', 'van']:
+            return 'Commercial'
+        return 'Passenger'
+
+    def _map_body_style(self, doors):
+        """Map doors to body style"""
+        if not doors:
+            return '4 Door'
+        doors = int(doors)
+        if doors == 2:
+            return '2 Door'
+        elif doors == 3:
+            return '3 Door'
+        elif doors == 5:
+            return '5 Door'
+        else:
+            return '4 Door'
+
+    def load_data_files(self):
+        """Load available CSV data files"""
+        try:
+            data_dir = "./data"
+            if os.path.exists(data_dir):
+                csv_files = glob.glob(os.path.join(data_dir, "*.csv"))
+                self.data_files = [os.path.basename(f) for f in csv_files]
+                logger.info(f"✅ Found {len(self.data_files)} CSV files: {self.data_files}")
+            else:
+                self.data_files = []
+                logger.warning("❌ Data directory not found")
+        except Exception as e:
+            logger.error(f"❌ Failed to load data files: {e}")
+            self.data_files = []
+
+    def search_data_files(self, make=None, model=None, year_min=None, year_max=None, 
+                         body_type=None, fuel_type=None, max_odometer=None, 
+                         max_price=None, selected_file=None, max_results=100, show_dealer_stats=True):
+        """Search through CSV data files using pandas filtering"""
+        try:
+            if not self.data_files:
+                return "❌ No CSV data files available", pd.DataFrame()
+            
+            # Use selected file or default to first available
+            if selected_file and selected_file in self.data_files:
+                file_to_search = selected_file
+            else:
+                file_to_search = self.data_files[0] if self.data_files else None
+            
+            if not file_to_search:
+                return "❌ No valid file selected", pd.DataFrame()
+            
+            file_path = os.path.join("./data", file_to_search)
+            
+            # Load the CSV file
+            logger.info(f"🔍 Loading data from: {file_to_search}")
+            
+            # Read CSV with error handling for different encodings
+            try:
+                df = pd.read_csv(file_path, encoding='utf-8')
+            except UnicodeDecodeError:
+                try:
+                    df = pd.read_csv(file_path, encoding='latin-1')
+                except:
+                    df = pd.read_csv(file_path, encoding='cp1252')
+            
+            # Convert column names to lowercase for easier matching
+            df.columns = df.columns.str.lower().str.strip()
+            
+            original_count = len(df)
+            
+            # Apply filters using correct column names from the dataset
+            if make and 'make' in df.columns:
+                df = df[df['make'].str.contains(make, case=False, na=False)]
+            
+            if model and 'model' in df.columns:
+                df = df[df['model'].str.contains(model, case=False, na=False)]
+            
+            if year_min and 'manu_year' in df.columns:
+                df = df[pd.to_numeric(df['manu_year'], errors='coerce') >= year_min]
+            
+            if year_max and 'manu_year' in df.columns:
+                df = df[pd.to_numeric(df['manu_year'], errors='coerce') <= year_max]
+            
+            if body_type and 'vehicle_body_type' in df.columns:
+                df = df[df['vehicle_body_type'].str.contains(body_type, case=False, na=False)]
+            
+            if fuel_type and 'vehicle_fuel_type' in df.columns:
+                df = df[df['vehicle_fuel_type'].str.contains(fuel_type, case=False, na=False)]
+            
+            if max_odometer and 'odometer' in df.columns:
+                df = df[pd.to_numeric(df['odometer'], errors='coerce') <= max_odometer]
+            
+            if max_price and 'advertised_price' in df.columns:
+                df = df[pd.to_numeric(df['advertised_price'], errors='coerce') <= max_price]
+            
+            filtered_count = len(df)
+            
+            if df.empty:
+                return f"✅ Searched {file_to_search} ({original_count:,} records) - No matches found", pd.DataFrame()
+            
+            # Create dealer ranking summary
+            if show_dealer_stats and 'dealer_trading_name' in df.columns:
+                dealer_summary = self._create_dealer_summary(df)
+                return f"✅ Found {filtered_count:,} matches from {original_count:,} records in {file_to_search}", dealer_summary
+            else:
+                # Return basic summary without dealer rankings
+                summary_df = pd.DataFrame({
+                    'Total Matches': [filtered_count],
+                    'File Searched': [file_to_search]
+                })
+                return f"✅ Found {filtered_count:,} matches from {original_count:,} records in {file_to_search}", summary_df
+                
+        except Exception as e:
+            logger.error(f"❌ Search error: {e}")
+            return f"❌ Error searching data: {str(e)}", pd.DataFrame()
+
+    def _create_dealer_summary(self, df):
+        """Create dealer ranking summary showing top dealers by car count with expandable car lists"""
+        try:
+            logger.info(f"📊 Creating dealer summary from {len(df)} matching cars...")
+            
+            # Count cars per dealer
+            dealer_counts = df['dealer_trading_name'].value_counts()
+            
+            # Get top 10 dealers (increased from 5 to show more)
+            top_dealers = dealer_counts.head(10)
+            
+            # Create HTML with expandable sections for each dealer
+            html_content = ""
+            
+            # Add dealer sections
+            for rank, (dealer_name, car_count) in enumerate(top_dealers.items(), 1):
+                # Get cars for this dealer
+                dealer_cars = df[df['dealer_trading_name'] == dealer_name]
+                
+                # Create rank emoji
+                rank_emoji = "🥇" if rank == 1 else "🥈" if rank == 2 else "🥉" if rank == 3 else f"#{rank}"
+                
+                html_content += f"""
+                <details style="margin-bottom: 10px; border: 1px solid #ddd; padding: 5px; border-radius: 5px;">
+                    <summary style="font-weight: bold; cursor: pointer; padding: 5px;">
+                        {rank_emoji} {dealer_name} ({car_count} cars)
+                    </summary>
+                    <div style="margin-top: 10px; max-height: 300px; overflow-y: auto;">
+                """
+                
+                # Add individual cars
+                for idx, (_, car) in enumerate(dealer_cars.head(20).iterrows()):  # Limit to 20 cars per dealer
+                    # Extract car details safely
+                    make = car.get('make', 'Unknown')
+                    model = car.get('model', 'Unknown')
+                    year = car.get('manu_year', 'Unknown')
+                    odometer = car.get('odometer', 'Unknown')
+                    price = car.get('advertised_price', 'Unknown')
+                    body_type = car.get('vehicle_body_type', 'Unknown')
+                    fuel_type = car.get('vehicle_fuel_type', 'Unknown')
+                    transmission = car.get('vehicle_transmission_type', 'Unknown')
+                    
+                    # Format odometer
+                    if odometer != 'Unknown' and pd.notna(odometer):
+                        try:
+                            odometer_str = f"{int(float(odometer)):,} km"
+                        except:
+                            odometer_str = str(odometer)
+                    else:
+                        odometer_str = "Unknown km"
+                    
+                    # Format price
+                    if price != 'Unknown' and pd.notna(price):
+                        try:
+                            price_str = f"${int(float(price)):,}"
+                        except:
+                            price_str = str(price)
+                    else:
+                        price_str = "Price on request"
+                    
+                    html_content += f"""
+                        <div style="padding: 8px; margin: 4px 0; background: #f9f9f9; border-radius: 3px; border-left: 3px solid #007bff;">
+                            <strong>{year} {make} {model}</strong> - {price_str}<br>
+                            <small style="color: #666;">{body_type} • {fuel_type} • {transmission} • {odometer_str}</small>
+                        </div>
+                    """
+                
+                # Add "show more" if there are more than 20 cars
+                if len(dealer_cars) > 20:
+                    html_content += f"""
+                        <div style="padding: 8px; margin: 4px 0; background: #e9ecef; border-radius: 3px; text-align: center; font-style: italic;">
+                            ... and {len(dealer_cars) - 20} more cars
+                        </div>
+                    """
+                
+                html_content += """
+                    </div>
+                </details>
+                """
+            
+            logger.info(f"✅ Created dealer summary. Top dealer: {top_dealers.index[0]} with {top_dealers.iloc[0]} cars")
+            return html_content
+            
+        except Exception as e:
+            logger.error(f"❌ Error creating dealer summary: {e}")
+            return f"<div style='color: red; padding: 20px;'>❌ Error creating dealer summary: {str(e)}</div>"
+
+# Initialize the matcher with local model
+matcher = CarDealerMatcher(model_path="./autogluon_model")
+
+# Initialize a separate simple matcher for the simple tab
+simple_matcher = CarDealerMatcher(model_path="./simple_autogluon_models")
+
+# Define structured make-model data for dynamic dropdowns
+MAKE_MODEL_DATA = {
+    "Toyota": [
+        "Camry",
+        "Corolla",
+        "HiAce",
+        "Hilux",
+        "Kluger",
+        "Landcruiser",
+        "Landcruiser Prado",
+        "Prius V",
+        "RAV4",
+        "Yaris",
+        "Yaris Cross"
+    ],
+    "Audi": [
+        "Q3",
+        "SQ7",
+        "TT"
+    ],
+    "BMW": [
+        "125I",
+        "5",
+        "M2"
+    ],
+    "Fiat": [
+        "500",
+        "500C",
+        "Ducato"
+    ],
+    "Ford": [
+        "Everest",
+        "F150",
+        "Falcon",
+        "Fiesta",
+        "Ranger",
+        "Territory"
+    ],
+    "GWM": [
+        "Haval H6"
+    ],
+    "Great Wall": [
+        "Steed"
+    ],
+    "Holden": [
+        "Calais",
+        "Captiva",
+        "Colorado",
+        "Colorado 7",
+        "Commodore",
+        "Cruze",
+        "Trax",
+        "UTE"
+    ],
+    "Honda": [
+        "CR-V"
+    ],
+    "Hyundai": [
+        "Accent",
+        "Elantra",
+        "I30",
+        "IX35",
+        "Iload",
+        "Kona",
+        "Santa FE",
+        "Tucson",
+        "Veloster"
+    ],
+    "Isuzu": [
+        "D-MAX"
+    ],
+    "Jaguar": [
+        "E-Pace"
+    ],
+    "Jeep": [
+        "Grand Cherokee"
+    ],
+    "Kia": [
+        "Cerato",
+        "Optima",
+        "Sorento",
+        "Sportage"
+    ],
+    "LDV": [
+        "D90",
+        "Deliver 9"
+    ],
+    "Land Rover": [
+        "Discovery Sport"
+    ],
+    "MG": [
+        "MG3 Auto"
+    ],
+    "Mazda": [
+        "3",
+        "6",
+        "BT-50",
+        "CX-3",
+        "CX-30",
+        "CX-5",
+        "CX-9",
+        "MX-5"
+    ],
+    "Mercedes-Benz": [
+        "C180",
+        "C250",
+        "E350",
+        "EQS",
+        "GL320",
+        "GLC250",
+        "SL400",
+        "Sprinter"
+    ],
+    "Mini": [
+        "3D Hatch"
+    ],
+    "Mitsubishi": [
+        "ASX",
+        "Eclipse Cross",
+        "Lancer",
+        "Outlander",
+        "Pajero Sport",
+        "Triton"
+    ],
+    "Nissan": [
+        "Maxima",
+        "Navara",
+        "Pathfinder",
+        "Patrol",
+        "Qashqai",
+        "Skyline",
+        "X-Trail"
+    ],
+    "Porsche": [
+        "Cayenne",
+        "Macan"
+    ],
+    "Renault": [
+        "Captur",
+        "Megane"
+    ],
+    "Skoda": [
+        "Octavia"
+    ],
+    "Subaru": [
+        "Forester",
+        "Impreza",
+        "Liberty",
+        "XV"
+    ],
+    "Suzuki": [
+        "Jimny",
+        "Swift"
+    ],
+    "Volkswagen": [
+        "Amarok",
+        "Golf",
+        "Polo",
+        "T-ROC",
+        "Tiguan"
+    ],
+    "Volvo": [
+        "XC40",
+        "XC60"
+    ]
+}
+
+# Extract makes list for dropdown
+CAR_MAKES = list(MAKE_MODEL_DATA.keys())
+
+# Define other dropdown options
+BODY_TYPES = ['Sedan', 'Hatchback', 'SUV', 'Wagon', 'Convertible', 'Coupe', 'Ute', 'Van']
+FUEL_TYPES = ['Petrol', 'Diesel', 'Hybrid', 'Electric', 'LPG']
+TRANSMISSION_TYPES = ['Automatic', 'Manual', 'CVT']
+DRIVE_TYPES = ['Front Wheel Drive', 'Rear Wheel Drive', 'All Wheel Drive', '4x4']
+SEGMENTS = ['Light', 'Small', 'Medium', 'Large', 'Upper Large', 'Luxury', 'Sports']
+CONDITIONS = ['New', 'Used', 'Demo']
+
+def update_models(make):
+    """Update model choices based on selected make"""
+    if make in MAKE_MODEL_DATA:
+        models = MAKE_MODEL_DATA[make]
+        return gr.Dropdown(choices=models, value=models[0] if models else None)
+    else:
+        return gr.Dropdown(choices=[], value=None)
+
+def predict_dealers_interface(make, model, year, body_type, fuel_type, transmission, 
+                            odometer, doors, seats, engine_size, power, cylinders,
+                            safety_rating, drive_type, segment, condition, selected_model):
+    """Interface function for Gradio"""
+    return matcher.predict_dealers(make, model, year, body_type, fuel_type, transmission,
+                                 odometer, doors, seats, engine_size, power, cylinders,
+                                 safety_rating, drive_type, segment, condition, selected_model)
+
+def search_data_interface(make, model, year_min, year_max, body_type, fuel_type, 
+                         max_odometer, max_price, selected_file, max_results, show_dealer_stats):
+    """Interface function for traditional data search"""
+    message, result_data = matcher.search_data_files(make, model, year_min, year_max,
+                                                     body_type, fuel_type, max_odometer,
+                                                     max_price, selected_file, max_results, show_dealer_stats)
+    
+    if isinstance(result_data, pd.DataFrame) and result_data.empty:
+        return message, "No results to display", ""
+    elif isinstance(result_data, str):  # HTML from _create_dealer_summary
+        # Extract stats for info display
+        if "Top dealer:" in message:
+            info_text = f"**🏆 Dealer Rankings with Expandable Car Lists**\n\n"
+            info_text += "Click on any dealer name to see their individual car listings with prices and specifications."
+        else:
+            info_text = f"**📊 Search completed successfully**\n\n"
+        
+        return message, info_text, result_data
+    else:
+        # Handle DataFrame case (when show_dealer_stats=False)
+        if hasattr(result_data, 'empty') and not result_data.empty:
+            info_text = f"**📊 Search completed successfully**\n\n"
+            html_table = result_data.to_html(classes='table table-striped', 
+                                           table_id='search-results', escape=False, index=False)
+            return message, info_text, html_table
+        else:
+            return message, "No results to display", ""
+
+def simple_search_data_interface(make, model, year, max_odometer, selected_file, max_results, show_dealer_stats):
+    """Interface function for simple traditional data search"""
+    # Convert simple parameters to traditional search format
+    # Use the year as both min and max for exact year matching
+    year_min = year if year else None
+    year_max = year if year else None
+    
+    message, result_data = matcher.search_data_files(
+        make=make, 
+        model=model, 
+        year_min=year_min, 
+        year_max=year_max,
+        body_type=None,  # Not used in simple search
+        fuel_type=None,  # Not used in simple search
+        max_odometer=max_odometer,
+        max_price=None,  # Not used in simple search
+        selected_file=selected_file, 
+        max_results=max_results, 
+        show_dealer_stats=show_dealer_stats
+    )
+    
+    if isinstance(result_data, pd.DataFrame) and result_data.empty:
+        return message, "No results to display", ""
+    elif isinstance(result_data, str):  # HTML from _create_dealer_summary
+        # Extract stats for info display
+        if "Top dealer:" in message:
+            info_text = f"**🏆 Dealer Rankings with Expandable Car Lists**\n\n"
+            info_text += "Click on any dealer name to see their individual car listings with prices and specifications."
+        else:
+            info_text = f"**📊 Search completed successfully**\n\n"
+        
+        return message, info_text, result_data
+    else:
+        # Handle DataFrame case (when show_dealer_stats=False)
+        if hasattr(result_data, 'empty') and not result_data.empty:
+            info_text = f"**📊 Search completed successfully**\n\n"
+            html_table = result_data.to_html(classes='table table-striped', 
+                                           table_id='search-results', escape=False, index=False)
+            return message, info_text, html_table
+        else:
+            return message, "No results to display", ""
+
+# Create the modern Gradio interface
+with gr.Blocks(
+    title="🚗 Swiper Match - Car Dealer Predictor", 
+    theme=gr.themes.Default(),
+    css="""
+    .gradio-container {
+        max-width: 1200px !important;
+        margin: 0 auto !important;
+    }
+    """
+) as demo:
+    
+    gr.Markdown("""
+    # 🚗 Swiper Match - Car Dealer Predictor
+    ### AI-Powered Dealer Matching Based on Vehicle Specifications
+    Find the perfect dealer for your dream car using machine learning
+    """)
+    
+    gr.Markdown("""
+    **🎯 How it works:** This tool analyzes vehicle specifications to predict which dealers are most likely to have cars matching your preferences. The model focuses on technical specifications, not pricing.
+    """)
+    
+    with gr.Tabs():
+        # Simple Tab
+        with gr.Tab("🔍 Simple"):
+            gr.Markdown("### Quick Car Dealer Search")
+            gr.Markdown("Enter just the basic details for a quick recommendation")
+            
+            # Model Selection for Simple Tab
+            simple_model_selection = gr.Dropdown(
+                choices=simple_matcher.available_models if simple_matcher.model_loaded else ['Model not loaded'],
+                label="🤖 Select AI Model",
+                value=simple_matcher.available_models[0] if simple_matcher.available_models else 'Model not loaded',
+                info="WeightedEnsemble_L3 provides the best overall performance"
+            )
+            
+            with gr.Row():
+                # Basic inputs
+                with gr.Column(scale=1):
+                    simple_make = gr.Dropdown(choices=CAR_MAKES, label="Make", value="Toyota")
+                    simple_model = gr.Dropdown(choices=MAKE_MODEL_DATA["Toyota"], label="Model", value="Camry")
+                    
+                with gr.Column(scale=1):
+                    simple_year = gr.Number(label="Year", value=2020, minimum=1990, maximum=2025)
+                    simple_odometer = gr.Number(label="Odometer (km)", value=50000, minimum=0)
+            
+            # Simple prediction button
+            simple_predict_btn = gr.Button(
+                "🎯 Find Best Dealers (Simple)",
+                variant="primary",
+                size="lg"
+            )
+            
+            # Simple Results Section
+            with gr.Row():
+                with gr.Column(scale=1):
+                    simple_top_dealer = gr.Textbox(
+                        label="🏆 Top Recommended Dealer",
+                        interactive=False,
+                        lines=2
+                    )
+                    simple_confidence = gr.Textbox(
+                        label="🎯 Confidence Score",
+                        interactive=False,
+                        lines=1
+                    )
+                with gr.Column(scale=2):
+                    simple_detailed_results = gr.Markdown(
+                        label="📊 Results",
+                        value="Click 'Find Best Dealers (Simple)' to see recommendations..."
+                    )
+        
+        # Detailed Tab 
+        with gr.Tab("⚙️ Detailed"):
+            gr.Markdown("### Advanced Car Dealer Search")
+            gr.Markdown("Specify detailed vehicle characteristics for more precise recommendations")
+            
+            # Model Selection Section
+            with gr.Row():
+                model_selection = gr.Dropdown(
+                    choices=matcher.available_models if matcher.model_loaded else ['Model not loaded'],
+                    label="🤖 Select AI Model",
+                    value=matcher.available_models[0] if matcher.available_models else 'Model not loaded',
+                    info="WeightedEnsemble_L3 provides the best overall performance",
+                    scale=2
+                )
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    **Available Models:**
+                    - **WeightedEnsemble**: Best performance (combines all models)
+                    - **RandomForest**: Tree-based, interpretable
+                    - **XGBoost**: Gradient boosting, fast
+                    - **NeuralNet**: Deep learning, complex patterns
+                    """)
+            
+            with gr.Row():
+                # Basic Vehicle Info
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🚗 Basic Vehicle Information")
+                    
+                    make = gr.Dropdown(choices=CAR_MAKES, label="Make", value="Toyota")
+                    model = gr.Dropdown(choices=MAKE_MODEL_DATA["Toyota"], label="Model", value="Camry")
+                    year = gr.Number(label="Year", value=2020, minimum=1990, maximum=2025)
+                    condition = gr.Dropdown(choices=CONDITIONS, label="Condition", value="Used")
+                    
+                # Body & Style
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🏗️ Body & Style")
+                    
+                    body_type = gr.Dropdown(choices=BODY_TYPES, label="Body Type", value="Sedan")
+                    segment = gr.Dropdown(choices=SEGMENTS, label="Vehicle Segment", value="Medium")
+                    doors = gr.Number(label="Doors", value=4, minimum=2, maximum=6)
+                    seats = gr.Number(label="Seats", value=5, minimum=2, maximum=9)
+                    
+                # Engine & Performance  
+                with gr.Column(scale=1):
+                    gr.Markdown("### ⚡ Engine & Performance")
+                    
+                    fuel_type = gr.Dropdown(choices=FUEL_TYPES, label="Fuel Type", value="Petrol")
+                    transmission = gr.Dropdown(choices=TRANSMISSION_TYPES, label="Transmission", value="Automatic")
+                    engine_size = gr.Number(label="Engine Size (L)", value=2.0, minimum=0.5, maximum=8.0)
+                    cylinders = gr.Number(label="Cylinders", value=4, minimum=2, maximum=12)
+            
+            with gr.Row():
+                # Technical Details
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🔧 Technical Details")
+                    
+                    power = gr.Number(label="Power (HP)", value=150, minimum=50, maximum=1000)
+                    drive_type = gr.Dropdown(choices=DRIVE_TYPES, label="Drive Type", value="Front Wheel Drive")
+                    safety_rating = gr.Number(label="Safety Rating (1-5)", value=5, minimum=1, maximum=5)
+                    
+                # Usage & History
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📊 Usage & History")
+                    
+                    odometer = gr.Number(label="Odometer (km)", value=50000, minimum=0)
+                    
+            # Detailed prediction button
+            predict_btn = gr.Button(
+                "🎯 Find Best Dealers (Detailed)",
+                variant="primary",
+                size="lg"
+            )
+            
+            # Detailed Results Section
+            with gr.Row():
+                with gr.Column(scale=1):
+                    top_dealer = gr.Textbox(
+                        label="🏆 Top Recommended Dealer",
+                        interactive=False,
+                        lines=2
+                    )
+                    confidence = gr.Textbox(
+                        label="🎯 Confidence Score",
+                        interactive=False,
+                        lines=1
+                    )
+                with gr.Column(scale=2):
+                    detailed_results = gr.Markdown(
+                        label="📊 Detailed Results",
+                        value="Click 'Find Best Dealers (Detailed)' to see AI recommendations..."
+                    )
+        
+        # Traditional Search Tab
+        with gr.Tab("📊 Traditional Search"):
+            gr.Markdown("### CSV Data File Search")
+            gr.Markdown("Search through car listing CSV files and rank dealers by inventory size")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🗂️ File Selection")
+                    selected_file = gr.Dropdown(
+                        choices=matcher.data_files,
+                        label="Select CSV File",
+                        value=matcher.data_files[0] if matcher.data_files else None,
+                        info=f"Available files: {len(matcher.data_files)}"
+                    )
+                    
+                    max_results = gr.Number(
+                        label="Max Results",
+                        value=100,
+                        minimum=1,
+                        maximum=1000,
+                        info="Limit number of results returned"
+                    )
+                    
+                    show_dealer_stats = gr.Checkbox(
+                        label="📊 Show Dealer Rankings",
+                        value=True,
+                        info="Rank dealers by number of matching cars"
+                    )
+                
+                with gr.Column(scale=2):
+                    gr.Markdown("### 🔍 Search Filters")
+                    
+                    with gr.Row():
+                        search_make = gr.Textbox(
+                            label="Make (contains)",
+                            placeholder="e.g., Toyota, Ford",
+                            info="Search for car manufacturer"
+                        )
+                        search_model = gr.Textbox(
+                            label="Model (contains)",
+                            placeholder="e.g., Camry, Focus",
+                            info="Search for car model"
+                        )
+                    
+                    with gr.Row():
+                        year_min = gr.Number(
+                            label="Year (Min)",
+                            value=2015,
+                            minimum=1980,
+                            maximum=2025,
+                            info="Minimum manufacturing year"
+                        )
+                        year_max = gr.Number(
+                            label="Year (Max)",
+                            value=2024,
+                            minimum=1980,
+                            maximum=2025,
+                            info="Maximum manufacturing year"
+                        )
+                    
+                    with gr.Row():
+                        search_body_type = gr.Textbox(
+                            label="Body Type (contains)",
+                            placeholder="e.g., sedan, suv, hatch",
+                            info="Vehicle body style"
+                        )
+                        search_fuel_type = gr.Textbox(
+                            label="Fuel Type (contains)",
+                            placeholder="e.g., petrol, diesel, electric",
+                            info="Fuel/energy type"
+                        )
+                    
+                    with gr.Row():
+                        max_odometer = gr.Number(
+                            label="Max Odometer (km)",
+                            minimum=0,
+                            info="Maximum mileage"
+                        )
+                        max_price = gr.Number(
+                            label="Max Price (AUD)",
+                            minimum=0,
+                            info="Maximum advertised price"
+                        )
+            
+            # Traditional search button
+            search_btn = gr.Button(
+                "🔍 Search CSV Data",
+                variant="primary",
+                size="lg"
+            )
+            
+            # Traditional Search Results Section
+            with gr.Row():
+                search_status = gr.Textbox(
+                    label="🔍 Search Status",
+                    interactive=False,
+                    lines=2
+                )
+            
+            with gr.Row():
+                search_info = gr.Markdown(
+                    label="📊 Results Info",
+                    value="Click 'Search CSV Data' to start searching..."
+                )
+            
+            with gr.Row():
+                search_results_table = gr.HTML(
+                    label="📋 Search Results",
+                    value="<p>No search performed yet</p>"
+                )
+            
+            # Data file info section
+            gr.Markdown(f"""
+            ---
+            ### 📁 Available Data Files
+            
+            **Files Found:** {len(matcher.data_files)}
+            
+            **File List:**
+            {chr(10).join([f'• {file}' for file in matcher.data_files]) if matcher.data_files else '• No CSV files found in ./data directory'}
+            
+            ### 🔍 Search Features
+            
+            **📊 Dealer Ranking:** Dealers ranked by number of cars matching your criteria
+            **🏆 Inventory Priority:** Dealers with more matching inventory appear first
+            **📈 Column Mapping:** Uses actual dataset columns:
+            - **Make/Model:** `make`, `model`
+            - **Year:** `manu_year` (manufacturing year)
+            - **Body Type:** `vehicle_body_type`
+            - **Fuel Type:** `vehicle_fuel_type`
+            - **Transmission:** `vehicle_transmission_type`
+            - **Mileage:** `odometer`
+            - **Price:** `advertised_price`
+            - **Dealer:** `dealer_trading_name`
+            - **Location:** `dealer_city`, `dealer_state`
+            
+            ### 📊 Dealer Ranking System
+            
+            **How it works:** Counts how many cars each dealer has that match your search criteria
+            **Ranking Logic:** Dealers with more matching cars get better ranks (Rank 1 = most inventory)
+            **Sorting:** Results sorted by dealer inventory count first, then by price
+            **Performance:** Fast counting using pandas group operations
+            """)
+        
+        # Traditional Simple Search Tab
+        with gr.Tab("🔍 Traditional Simple Search"):
+            gr.Markdown("### Quick CSV Data Search")
+            gr.Markdown("Simple search through car listing CSV files with basic filters")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🗂️ File & Options")
+                    simple_search_file = gr.Dropdown(
+                        choices=matcher.data_files,
+                        label="Select CSV File",
+                        value=matcher.data_files[0] if matcher.data_files else None,
+                        info=f"Available files: {len(matcher.data_files)}"
+                    )
+                    
+                    simple_max_results = gr.Number(
+                        label="Max Results",
+                        value=100,
+                        minimum=1,
+                        maximum=1000,
+                        info="Limit number of results returned"
+                    )
+                    
+                    simple_show_dealer_stats = gr.Checkbox(
+                        label="📊 Show Dealer Rankings",
+                        value=True,
+                        info="Rank dealers by number of matching cars"
+                    )
+                
+                with gr.Column(scale=2):
+                    gr.Markdown("### 🔍 Basic Search Filters")
+                    
+                    with gr.Row():
+                        simple_search_make = gr.Dropdown(
+                            choices=CAR_MAKES, 
+                            label="Make", 
+                            value="Toyota",
+                            info="Select car manufacturer"
+                        )
+                        simple_search_model = gr.Dropdown(
+                            choices=MAKE_MODEL_DATA["Toyota"], 
+                            label="Model", 
+                            value="Camry",
+                            info="Select car model"
+                        )
+                    
+                    with gr.Row():
+                        simple_search_year = gr.Number(
+                            label="Year",
+                            value=2020,
+                            minimum=1990,
+                            maximum=2025,
+                            info="Specific year to search for"
+                        )
+                        simple_search_max_odometer = gr.Number(
+                            label="Max Odometer (km)",
+                            value=100000,
+                            minimum=0,
+                            info="Maximum mileage"
+                        )
+            
+            # Simple traditional search button
+            simple_search_btn = gr.Button(
+                "🔍 Search CSV Data (Simple)",
+                variant="primary",
+                size="lg"
+            )
+            
+            # Simple Traditional Search Results Section
+            with gr.Row():
+                simple_search_status = gr.Textbox(
+                    label="🔍 Search Status",
+                    interactive=False,
+                    lines=2
+                )
+            
+            with gr.Row():
+                simple_search_info = gr.Markdown(
+                    label="📊 Results Info",
+                    value="Click 'Search CSV Data (Simple)' to start searching..."
+                )
+            
+            with gr.Row():
+                simple_search_results_table = gr.HTML(
+                    label="📋 Search Results",
+                    value="<p>No search performed yet</p>"
+                )
+            
+            gr.Markdown("""
+            ---
+            ### 🎯 Simple Search Features
+            
+            **Quick Setup:** Just select make, model, year, and max odometer
+            **Smart Defaults:** Pre-filled with popular choices
+            **Same Power:** Uses the same CSV search engine as Traditional Search
+            **Dealer Ranking:** Get dealers ranked by inventory matching your criteria
+            **Fast Results:** Simplified interface for quicker searches
+            """)
+    
+    # Model Information Footer
+    detailed_status_emoji = "✅" if matcher.model_loaded else "❌"
+    simple_status_emoji = "✅" if simple_matcher.model_loaded else "❌"
+    
+    gr.Markdown(f"""
+    ---
+    ### 📊 Model Information
+    
+    #### 🔧 **Detailed Model** (Advanced Search)
+    **Status:** {detailed_status_emoji} {"Model Loaded Successfully" if matcher.model_loaded else "Model Not Available"}  
+    **Path:** ./autogluon_model  
+    **Trained Dealers:** {len(matcher.trained_dealers) if matcher.model_loaded else "N/A"}  
+    **Available Models:** {len(matcher.available_models) if matcher.model_loaded else "N/A"} ({', '.join(matcher.available_models[:3]) + ('...' if len(matcher.available_models) > 3 else '') if matcher.model_loaded and matcher.available_models else "N/A"})  
+    **Features:** 23 vehicle specifications (no pricing data)  
+    
+    #### 🔍 **Simple Model** (Quick Search)  
+    **Status:** {simple_status_emoji} {"Model Loaded Successfully" if simple_matcher.model_loaded else "Model Not Available"}  
+    **Path:** ./simple_autogluon_models  
+    **Trained Dealers:** {len(simple_matcher.trained_dealers) if simple_matcher.model_loaded else "N/A"}  
+    **Available Models:** {len(simple_matcher.available_models) if simple_matcher.model_loaded else "N/A"} ({', '.join(simple_matcher.available_models[:3]) + ('...' if len(simple_matcher.available_models) > 3 else '') if simple_matcher.model_loaded and simple_matcher.available_models else "N/A"})  
+    **Features:** Subset of vehicle specifications for faster inference  
+    
+    #### 🤖 **Architecture**
+    **Framework:** AutoGluon TabularPredictor  
+    **Ensemble Learning:** Multiple algorithms combined via weighted voting  
+    **Algorithms:** RandomForest, XGBoost, NeuralNetTorch, CatBoost, LightGBM  
+    **Task:** Multi-class classification for dealer prediction
+    """)
+    
+    # Set up the prediction functions
+    
+    # Simple prediction function (with default values for missing inputs)
+    def simple_predict_dealers_interface(simple_make, simple_model, simple_year, simple_odometer, simple_model_selection):
+        """Simple interface function for Gradio with conditional parameters"""
+        
+        return simple_matcher.predict_dealers(
+            make=simple_make, 
+            model=simple_model, 
+            year=simple_year, 
+            body_type=None,
+            fuel_type=None,
+            transmission=None,
+            odometer=simple_odometer, 
+            doors=None,
+            seats=None,
+            engine_size=None,
+            power=None,
+            cylinders=None,
+            safety_rating=None,
+            drive_type=None,
+            segment=None,
+            condition=None,
+            selected_model=simple_model_selection
+        )
+    
+    # Simple tab click event"
+    simple_predict_btn.click(
+        fn=simple_predict_dealers_interface,
+        inputs=[simple_make, simple_model, simple_year, simple_odometer, simple_model_selection],
+        outputs=[simple_top_dealer, simple_confidence, simple_detailed_results]
+    )
+    
+    # Detailed tab click event
+    predict_btn.click(
+        fn=predict_dealers_interface,
+        inputs=[make, model, year, body_type, fuel_type, transmission, 
+               odometer, doors, seats, engine_size, power, cylinders,
+               safety_rating, drive_type, segment, condition, model_selection],
+        outputs=[top_dealer, confidence, detailed_results]
+    )
+    
+    # Traditional search click event
+    search_btn.click(
+        fn=search_data_interface,
+        inputs=[search_make, search_model, year_min, year_max, search_body_type, 
+               search_fuel_type, max_odometer, max_price, selected_file, max_results, show_dealer_stats],
+        outputs=[search_status, search_info, search_results_table]
+    )
+    
+    # Simple traditional search click event
+    simple_search_btn.click(
+        fn=simple_search_data_interface,
+        inputs=[simple_search_make, simple_search_model, simple_search_year, simple_search_max_odometer, 
+               simple_search_file, simple_max_results, simple_show_dealer_stats],
+        outputs=[simple_search_status, simple_search_info, simple_search_results_table]
+    )
+    
+    # Set up dynamic model updating based on make selection
+    simple_make.change(
+        fn=update_models,
+        inputs=simple_make,
+        outputs=simple_model
+    )
+    
+    make.change(
+        fn=update_models,
+        inputs=make,
+        outputs=model
+    )
+    
+    # Simple traditional search make/model update
+    simple_search_make.change(
+        fn=update_models,
+        inputs=simple_search_make,
+        outputs=simple_search_model
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

core/__init__.py

@@ -0,0 +1 @@
+# Core modules for the Swiper Match application 

core/config.py

@@ -0,0 +1,231 @@
+"""
+Configuration file for Swiper Match application
+Contains all constants, dropdown data, and application settings
+"""
+
+import os
+
+# Hugging Face configuration
+HF_REPO_ID = "mzx/Swiper-Match"
+HF_TOKEN = os.getenv('HF_TOKEN')
+
+# Model paths
+DETAILED_MODEL_PATH = "./autogluon_model"
+SIMPLE_MODEL_PATH = "./simple_autogluon_models"
+DATA_DIR = "./data"
+
+# Define structured make-model data for dynamic dropdowns
+MAKE_MODEL_DATA = {
+    "Toyota": [
+        "Camry",
+        "Corolla",
+        "HiAce",
+        "Hilux",
+        "Kluger",
+        "Landcruiser",
+        "Landcruiser Prado",
+        "Prius V",
+        "RAV4",
+        "Yaris",
+        "Yaris Cross"
+    ],
+    "Audi": [
+        "Q3",
+        "SQ7",
+        "TT"
+    ],
+    "BMW": [
+        "125I",
+        "5",
+        "M2"
+    ],
+    "Fiat": [
+        "500",
+        "500C",
+        "Ducato"
+    ],
+    "Ford": [
+        "Everest",
+        "F150",
+        "Falcon",
+        "Fiesta",
+        "Ranger",
+        "Territory"
+    ],
+    "GWM": [
+        "Haval H6"
+    ],
+    "Great Wall": [
+        "Steed"
+    ],
+    "Holden": [
+        "Calais",
+        "Captiva",
+        "Colorado",
+        "Colorado 7",
+        "Commodore",
+        "Cruze",
+        "Trax",
+        "UTE"
+    ],
+    "Honda": [
+        "CR-V"
+    ],
+    "Hyundai": [
+        "Accent",
+        "Elantra",
+        "I30",
+        "IX35",
+        "Iload",
+        "Kona",
+        "Santa FE",
+        "Tucson",
+        "Veloster"
+    ],
+    "Isuzu": [
+        "D-MAX"
+    ],
+    "Jaguar": [
+        "E-Pace"
+    ],
+    "Jeep": [
+        "Grand Cherokee"
+    ],
+    "Kia": [
+        "Cerato",
+        "Optima",
+        "Sorento",
+        "Sportage"
+    ],
+    "LDV": [
+        "D90",
+        "Deliver 9"
+    ],
+    "Land Rover": [
+        "Discovery Sport"
+    ],
+    "MG": [
+        "MG3 Auto"
+    ],
+    "Mazda": [
+        "3",
+        "6",
+        "BT-50",
+        "CX-3",
+        "CX-30",
+        "CX-5",
+        "CX-9",
+        "MX-5"
+    ],
+    "Mercedes-Benz": [
+        "C180",
+        "C250",
+        "E350",
+        "EQS",
+        "GL320",
+        "GLC250",
+        "SL400",
+        "Sprinter"
+    ],
+    "Mini": [
+        "3D Hatch"
+    ],
+    "Mitsubishi": [
+        "ASX",
+        "Eclipse Cross",
+        "Lancer",
+        "Outlander",
+        "Pajero Sport",
+        "Triton"
+    ],
+    "Nissan": [
+        "Maxima",
+        "Navara",
+        "Pathfinder",
+        "Patrol",
+        "Qashqai",
+        "Skyline",
+        "X-Trail"
+    ],
+    "Porsche": [
+        "Cayenne",
+        "Macan"
+    ],
+    "Renault": [
+        "Captur",
+        "Megane"
+    ],
+    "Skoda": [
+        "Octavia"
+    ],
+    "Subaru": [
+        "Forester",
+        "Impreza",
+        "Liberty",
+        "XV"
+    ],
+    "Suzuki": [
+        "Jimny",
+        "Swift"
+    ],
+    "Volkswagen": [
+        "Amarok",
+        "Golf",
+        "Polo",
+        "T-ROC",
+        "Tiguan"
+    ],
+    "Volvo": [
+        "XC40",
+        "XC60"
+    ]
+}
+
+# Extract makes list for dropdown
+CAR_MAKES = list(MAKE_MODEL_DATA.keys())
+
+# Define other dropdown options
+BODY_TYPES = ['Sedan', 'Hatchback', 'SUV', 'Wagon', 'Convertible', 'Coupe', 'Ute', 'Van']
+FUEL_TYPES = ['Petrol', 'Diesel', 'Hybrid', 'Electric', 'LPG']
+TRANSMISSION_TYPES = ['Automatic', 'Manual', 'CVT']
+DRIVE_TYPES = ['Front Wheel Drive', 'Rear Wheel Drive', 'All Wheel Drive', '4x4']
+SEGMENTS = ['Light', 'Small', 'Medium', 'Large', 'Upper Large', 'Luxury', 'Sports']
+CONDITIONS = ['New', 'Used', 'Demo']
+
+# Default values
+DEFAULT_VALUES = {
+    'make': 'Toyota',
+    'model': 'Camry',
+    'year': 2020,
+    'body_type': 'Sedan',
+    'fuel_type': 'Petrol',
+    'transmission': 'Automatic',
+    'odometer': 50000,
+    'doors': 4,
+    'seats': 5,
+    'engine_size': 2.0,
+    'power': 150,
+    'cylinders': 4,
+    'safety_rating': 5,
+    'drive_type': 'Front Wheel Drive',
+    'segment': 'Medium',
+    'condition': 'Used',
+    'year_min': 2015,
+    'year_max': 2024,
+    'max_results': 100
+}
+
+# UI Configuration
+UI_CONFIG = {
+    'title': '🚗 Swiper Match - Car Dealer Predictor',
+    'max_width': '1200px',
+    'theme': 'light'
+}
+
+# Gradio CSS
+GRADIO_CSS = """
+.gradio-container {
+    max-width: 1200px !important;
+    margin: 0 auto !important;
+}
+""" 

core/matcher.py

@@ -0,0 +1,473 @@
+"""
+Car Dealer Matcher class for predicting best dealers based on vehicle specifications
+"""
+
+import pandas as pd
+import numpy as np
+import os
+import logging
+import glob
+from huggingface_hub import snapshot_download
+from autogluon.tabular import TabularPredictor
+
+from .config import HF_REPO_ID, HF_TOKEN, DATA_DIR
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
+
+class CarDealerMatcher:
+    def __init__(self, model_path: str = "./autogluon_model"):
+        self.model_path = model_path
+        self.predictor = None
+        self.trained_dealers = []
+        self.available_models = []
+        self.model_loaded = False
+        self.data_files = []
+        self.load_model()
+        self.load_data_files()
+    
+    def load_model(self):
+        """Load AutoGluon model from local directory or download from Hugging Face"""
+        try:
+            logger.info(f"🤖 Loading AutoGluon model from: {self.model_path}")
+            
+            # Check if model exists locally
+            if not os.path.exists(self.model_path):
+                logger.info(f"📥 Model not found locally. Downloading from Hugging Face: {HF_REPO_ID}")
+                try:
+                    # Download the model from Hugging Face
+                    downloaded_path = snapshot_download(
+                        repo_id=HF_REPO_ID,
+                        cache_dir="./hf_cache",
+                        token=HF_TOKEN,
+                        local_dir="./",
+                        local_dir_use_symlinks=False
+                    )
+                    logger.info(f"✅ Model downloaded successfully to: {downloaded_path}")
+                except Exception as download_error:
+                    logger.error(f"❌ Failed to download model from Hugging Face: {download_error}")
+                    self.model_loaded = False
+                    return
+            
+            # Load the model
+            if os.path.exists(self.model_path):
+                self.predictor = TabularPredictor.load(self.model_path)
+                self._extract_trained_dealers()
+                self._extract_available_models()
+                self.model_loaded = True
+                logger.info(f"✅ Model loaded successfully! Can predict for {len(self.trained_dealers)} dealers")
+                logger.info(f"🎯 Available models: {self.available_models}")
+            else:
+                logger.error(f"❌ Model directory still not found after download attempt: {self.model_path}")
+                self.model_loaded = False
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to load model: {e}")
+            self.model_loaded = False
+    
+    def _extract_trained_dealers(self):
+        """Extract trained dealers from the predictor"""
+        try:
+            if hasattr(self.predictor, 'class_labels'):
+                self.trained_dealers = list(self.predictor.class_labels)
+            else:
+                # Use a dummy prediction to extract dealer names
+                dummy_data = self._create_dummy_data()
+                proba_result = self.predictor.predict_proba(dummy_data)
+                if hasattr(proba_result, 'columns'):
+                    self.trained_dealers = list(proba_result.columns)
+                else:
+                    self.trained_dealers = ['Model loaded successfully']
+        except Exception as e:
+            self.trained_dealers = ['Model loaded successfully']
+            logger.warning(f"Could not extract dealer list: {e}")
+    
+    def _extract_available_models(self):
+        """Extract available models from the predictor"""
+        try:
+            if hasattr(self.predictor, 'model_names'):
+                raw_models = self.predictor.model_names()
+                print("my models", raw_models)
+                # Add ensemble options with user-friendly names
+                self.available_models = ['WeightedEnsemble_L3 (Best)', 'WeightedEnsemble_L2'] + [
+                    name for name in raw_models if 'WeightedEnsemble' not in name
+                ]
+         
+        except Exception as e:
+            self.available_models = ['WeightedEnsemble_L3 (Best)']
+            logger.warning(f"Could not extract model list: {e}")
+
+    def _create_dummy_data(self):
+        """Create dummy data with all required features"""
+        return pd.DataFrame([{
+            'make': 'toyota',
+            'model': 'camry',
+            'year': 2020,
+            'car_age': 4,  # Add the missing car_age feature (2024 - 2020 = 4)
+            'vehicle_body_type': 'sedan',
+            'vehicle_fuel_type': 'petrol',
+            'vehicle_transmission_type': 'automatic',
+            'odometer': 50000,
+            'vehicle_doors': 4,
+            'vehicle_seats': 5,
+            'series': 'unknown',
+            'variant': 'unknown',
+            'vehicle_body_type_group': 'Passenger',
+            'vehicle_body_type_style': '4 Door',
+            'vehicle_cylinder_description': '4 Cylinder',
+            'vehicle_cylinders': 4.0,
+            'vehicle_drive_type': 'Front Wheel Drive',
+            'vehicle_engine_size': 2.0,
+            'vehicle_power': 150.0,
+            'vehicle_safety_rating': 5,
+            'vehicle_segment': 'Medium',
+            'condition': 'Used',
+            'vehicle_type': 1
+        }])
+
+    def predict_dealers(self, make=None, model=None, year=None, body_type=None, fuel_type=None, transmission=None, 
+                       odometer=None, doors=None, seats=None, engine_size=None, power=None, cylinders=None, 
+                       safety_rating=None, drive_type=None, segment=None, condition=None, selected_model=None):
+        """Predict top dealers for the given car specifications using selected model"""
+        
+        if not self.model_loaded:
+            return "❌ AutoGluon model not loaded. Please check model directory availability.", "", ""
+        
+        try:
+            # Calculate car age (current year - vehicle year)
+            current_year = 2024  # You can use datetime.now().year for dynamic year
+            car_age = current_year - int(year) if year else None
+            
+            # Create input dataframe with only non-None values for AutoGluon model
+            car_data_dict = {}
+            
+            # Add parameters only if they are not None
+            if make is not None:
+                car_data_dict['make'] = make.lower()
+            if model is not None:
+                car_data_dict['model'] = model.lower()
+            if year is not None:
+                car_data_dict['year'] = int(year)
+            if car_age is not None:
+                car_data_dict['car_age'] = car_age
+            if body_type is not None:
+                car_data_dict['vehicle_body_type'] = body_type.lower()
+            if fuel_type is not None:
+                car_data_dict['vehicle_fuel_type'] = fuel_type.lower()
+            if transmission is not None:
+                car_data_dict['vehicle_transmission_type'] = transmission.lower()
+            if odometer is not None:
+                car_data_dict['odometer'] = int(odometer)
+            if doors is not None:
+                car_data_dict['vehicle_doors'] = float(doors)
+            if seats is not None:
+                car_data_dict['vehicle_seats'] = float(seats)
+            if engine_size is not None:
+                car_data_dict['vehicle_engine_size'] = float(engine_size)
+            if power is not None:
+                car_data_dict['vehicle_power'] = float(power)
+            if cylinders is not None:
+                car_data_dict['vehicle_cylinders'] = float(cylinders)
+            if safety_rating is not None:
+                car_data_dict['vehicle_safety_rating'] = float(safety_rating)
+            if drive_type is not None:
+                car_data_dict['vehicle_drive_type'] = drive_type
+            if segment is not None:
+                car_data_dict['vehicle_segment'] = segment
+            if condition is not None:
+                car_data_dict['condition'] = condition
+                
+            # Auto-generated features based on inputs (only if base inputs exist)
+            if body_type is not None:
+                car_data_dict['vehicle_body_type_group'] = self._map_body_type_group(body_type)
+            if doors is not None:
+                car_data_dict['vehicle_body_type_style'] = self._map_body_style(doors)
+            if cylinders is not None:
+                car_data_dict['vehicle_cylinder_description'] = f'{int(cylinders)} Cylinder'
+                
+            # Always include these if not specified (required for model compatibility)
+            if 'series' not in car_data_dict:
+                car_data_dict['series'] = 'unknown'
+            if 'variant' not in car_data_dict:
+                car_data_dict['variant'] = 'unknown'
+            if 'vehicle_type' not in car_data_dict:
+                car_data_dict['vehicle_type'] = 1  # Passenger vehicle
+            
+            car_data = pd.DataFrame([car_data_dict])
+            
+            # Get predictions using AutoGluon predictor with selected model
+            if selected_model and selected_model != 'WeightedEnsemble_L3 (Best)':
+                # Clean model name
+                clean_model = selected_model.replace(' (Best)', '')
+                try:
+                    proba_result = self.predictor.predict_proba(car_data, model=clean_model)
+                    model_used = selected_model
+                except Exception as model_error:
+                    logger.warning(f"Failed to use specific model {clean_model}: {model_error}")
+                    proba_result = self.predictor.predict_proba(car_data)
+                    model_used = "WeightedEnsemble_L3 (fallback)"
+            else:
+                proba_result = self.predictor.predict_proba(car_data)
+                model_used = "WeightedEnsemble_L3 (Best)"
+            
+            # Convert to dict format and get top-k predictions
+            if hasattr(proba_result, 'iloc'):
+                proba_dict = proba_result.iloc[0].to_dict()
+            else:
+                proba_dict = dict(zip(self.trained_dealers, proba_result[0]))
+            
+            # Sort by probability and get top 5
+            sorted_dealers = sorted(proba_dict.items(), key=lambda x: x[1], reverse=True)[:5]
+            
+            # Format results
+            top_dealer = sorted_dealers[0][0]
+            confidence = f"{sorted_dealers[0][1]:.2%}"
+            
+            # Create detailed results
+            results_text = "🏆 **Top 5 Recommended Dealers:**\n\n"
+            for i, (dealer, prob) in enumerate(sorted_dealers, 1):
+                emoji = "🥇" if i == 1 else "🥈" if i == 2 else "🥉" if i == 3 else "🔸"
+                results_text += f"{emoji} **{i}. {dealer}** - {prob:.1%} confidence\n"
+            
+            # Add car summary
+            car_summary = f"""
+            
+**🚗 Vehicle Specifications:**
+• **Make & Model:** {make} {model} ({year})
+• **Body Type:** {body_type} • **Segment:** {segment}
+• **Engine:** {engine_size}L, {cylinders} cylinders, {power}HP
+• **Drivetrain:** {fuel_type} • {transmission} • {drive_type}
+• **Details:** {doors} doors, {seats} seats • {odometer:,} km
+• **Condition:** {condition} • **Safety:** {safety_rating}★
+
+**🤖 Model:** {model_used}
+            """
+            
+            return f"🎯 **Best Match: {top_dealer}**", confidence, results_text + car_summary
+            
+        except Exception as e:
+            logger.error(f"Prediction error: {e}")
+            return f"❌ Error making prediction: {str(e)}", "", ""
+
+    def _map_body_type_group(self, body_type):
+        """Map body type to group"""
+        if not body_type:
+            return 'Passenger'
+        body_lower = body_type.lower()
+        if body_lower in ['ute', 'truck', 'van']:
+            return 'Commercial'
+        return 'Passenger'
+
+    def _map_body_style(self, doors):
+        """Map doors to body style"""
+        if not doors:
+            return '4 Door'
+        doors = int(doors)
+        if doors == 2:
+            return '2 Door'
+        elif doors == 3:
+            return '3 Door'
+        elif doors == 5:
+            return '5 Door'
+        else:
+            return '4 Door'
+
+    def load_data_files(self):
+        """Load available CSV data files"""
+        try:
+            if os.path.exists(DATA_DIR):
+                csv_files = glob.glob(os.path.join(DATA_DIR, "*.csv"))
+                self.data_files = [os.path.basename(f) for f in csv_files]
+                logger.info(f"✅ Found {len(self.data_files)} CSV files: {self.data_files}")
+            else:
+                self.data_files = []
+                logger.warning("❌ Data directory not found")
+        except Exception as e:
+            logger.error(f"❌ Failed to load data files: {e}")
+            self.data_files = []
+
+    def search_data_files(self, make=None, model=None, year_min=None, year_max=None, 
+                         year_value=None, year_range=None,
+                         body_type=None, fuel_type=None, max_odometer=None, 
+                         odometer_value=None, odometer_range=None,
+                         max_price=None, selected_file=None, max_results=100, show_dealer_stats=True):
+        """Search through CSV data files using pandas filtering"""
+        try:
+            if not self.data_files:
+                return "❌ No CSV data files available", pd.DataFrame()
+            
+            # Use selected file or default to first available
+            if selected_file and selected_file in self.data_files:
+                file_to_search = selected_file
+            else:
+                file_to_search = self.data_files[0] if self.data_files else None
+            
+            if not file_to_search:
+                return "❌ No valid file selected", pd.DataFrame()
+            
+            file_path = os.path.join(DATA_DIR, file_to_search)
+            
+            # Load the CSV file
+            logger.info(f"🔍 Loading data from: {file_to_search}")
+            
+            # Read CSV with error handling for different encodings
+            try:
+                df = pd.read_csv(file_path, encoding='utf-8')
+            except UnicodeDecodeError:
+                try:
+                    df = pd.read_csv(file_path, encoding='latin-1')
+                except:
+                    df = pd.read_csv(file_path, encoding='cp1252')
+            
+            # Convert column names to lowercase for easier matching
+            df.columns = df.columns.str.lower().str.strip()
+            
+            original_count = len(df)
+            
+            # Apply filters using correct column names from the dataset
+            if make and 'make' in df.columns:
+                df = df[df['make'].str.contains(make, case=False, na=False)]
+            
+            if model and 'model' in df.columns:
+                df = df[df['model'].str.contains(model, case=False, na=False)]
+            
+            # Handle year filtering - prioritize range-based search over min/max search
+            if year_value is not None and year_range is not None and 'manu_year' in df.columns:
+                # Symmetric range search: year_value ± year_range
+                min_year = year_value - year_range
+                max_year_range = year_value + year_range
+                year_numeric = pd.to_numeric(df['manu_year'], errors='coerce')
+                df = df[(year_numeric >= min_year) & (year_numeric <= max_year_range)]
+            elif year_min and 'manu_year' in df.columns:
+                df = df[pd.to_numeric(df['manu_year'], errors='coerce') >= year_min]
+            elif year_max and 'manu_year' in df.columns:
+                df = df[pd.to_numeric(df['manu_year'], errors='coerce') <= year_max]
+            
+            if body_type and 'vehicle_body_type' in df.columns:
+                df = df[df['vehicle_body_type'].str.contains(body_type, case=False, na=False)]
+            
+            if fuel_type and 'vehicle_fuel_type' in df.columns:
+                df = df[df['vehicle_fuel_type'].str.contains(fuel_type, case=False, na=False)]
+            
+            # Handle odometer filtering - prioritize range-based search over max search
+            if odometer_value is not None and odometer_range is not None and 'odometer' in df.columns:
+                # Symmetric range search: odometer_value ± odometer_range
+                min_odometer = odometer_value - odometer_range
+                max_odometer_range = odometer_value + odometer_range
+                odometer_numeric = pd.to_numeric(df['odometer'], errors='coerce')
+                df = df[(odometer_numeric >= min_odometer) & (odometer_numeric <= max_odometer_range)]
+            elif max_odometer and 'odometer' in df.columns:
+                # Fallback to max odometer filter if range search not specified
+                df = df[pd.to_numeric(df['odometer'], errors='coerce') <= max_odometer]
+            
+            if max_price and 'advertised_price' in df.columns:
+                df = df[pd.to_numeric(df['advertised_price'], errors='coerce') <= max_price]
+            
+            filtered_count = len(df)
+            
+            if df.empty:
+                return f"✅ Searched {file_to_search} ({original_count:,} records) - No matches found", pd.DataFrame()
+            
+            # Create dealer ranking summary
+            if show_dealer_stats and 'dealer_trading_name' in df.columns:
+                dealer_summary = self._create_dealer_summary(df)
+                return f"✅ Found {filtered_count:,} matches from {original_count:,} records in {file_to_search}", dealer_summary
+            else:
+                # Return basic summary without dealer rankings
+                summary_df = pd.DataFrame({
+                    'Total Matches': [filtered_count],
+                    'File Searched': [file_to_search]
+                })
+                return f"✅ Found {filtered_count:,} matches from {original_count:,} records in {file_to_search}", summary_df
+                
+        except Exception as e:
+            logger.error(f"❌ Search error: {e}")
+            return f"❌ Error searching data: {str(e)}", pd.DataFrame()
+
+    def _create_dealer_summary(self, df):
+        """Create dealer ranking summary showing top dealers by car count with expandable car lists"""
+        try:
+            logger.info(f"📊 Creating dealer summary from {len(df)} matching cars...")
+            
+            # Count cars per dealer
+            dealer_counts = df['dealer_trading_name'].value_counts()
+            
+            # Get top 10 dealers (increased from 5 to show more)
+            top_dealers = dealer_counts.head(10)
+            
+            # Create HTML with expandable sections for each dealer
+            html_content = ""
+            
+            # Add dealer sections
+            for rank, (dealer_name, car_count) in enumerate(top_dealers.items(), 1):
+                # Get cars for this dealer
+                dealer_cars = df[df['dealer_trading_name'] == dealer_name]
+                
+                # Create rank emoji
+                rank_emoji = "🥇" if rank == 1 else "🥈" if rank == 2 else "🥉" if rank == 3 else f"#{rank}"
+                
+                html_content += f"""
+                <details style="margin-bottom: 10px; border: 1px solid #ddd; padding: 5px; border-radius: 5px;">
+                    <summary style="font-weight: bold; cursor: pointer; padding: 5px;">
+                        {rank_emoji} {dealer_name} ({car_count} cars)
+                    </summary>
+                    <div style="margin-top: 10px; max-height: 300px; overflow-y: auto;">
+                """
+                
+                # Add individual cars
+                for idx, (_, car) in enumerate(dealer_cars.head(20).iterrows()):  # Limit to 20 cars per dealer
+                    # Extract car details safely
+                    make = car.get('make', 'Unknown')
+                    model = car.get('model', 'Unknown')
+                    year = car.get('manu_year', 'Unknown')
+                    odometer = car.get('odometer', 'Unknown')
+                    price = car.get('advertised_price', 'Unknown')
+                    body_type = car.get('vehicle_body_type', 'Unknown')
+                    fuel_type = car.get('vehicle_fuel_type', 'Unknown')
+                    transmission = car.get('vehicle_transmission_type', 'Unknown')
+                    
+                    # Format odometer
+                    if odometer != 'Unknown' and pd.notna(odometer):
+                        try:
+                            odometer_str = f"{int(float(odometer)):,} km"
+                        except:
+                            odometer_str = str(odometer)
+                    else:
+                        odometer_str = "Unknown km"
+                    
+                    # Format price
+                    if price != 'Unknown' and pd.notna(price):
+                        try:
+                            price_str = f"${int(float(price)):,}"
+                        except:
+                            price_str = str(price)
+                    else:
+                        price_str = "Price on request"
+                    
+                    html_content += f"""
+                        <div style="padding: 8px; margin: 4px 0; background: #f9f9f9; border-radius: 3px; border-left: 3px solid #007bff;">
+                            <strong>{year} {make} {model}</strong> - {price_str}<br>
+                            <small style="color: #666;">{body_type} • {fuel_type} • {transmission} • {odometer_str}</small>
+                        </div>
+                    """
+                
+                # Add "show more" if there are more than 20 cars
+                if len(dealer_cars) > 20:
+                    html_content += f"""
+                        <div style="padding: 8px; margin: 4px 0; background: #e9ecef; border-radius: 3px; text-align: center; font-style: italic;">
+                            ... and {len(dealer_cars) - 20} more cars
+                        </div>
+                    """
+                
+                html_content += """
+                    </div>
+                </details>
+                """
+            
+            logger.info(f"✅ Created dealer summary. Top dealer: {top_dealers.index[0]} with {top_dealers.iloc[0]} cars")
+            return html_content
+            
+        except Exception as e:
+            logger.error(f"❌ Error creating dealer summary: {e}")
+            return f"<div style='color: red; padding: 20px;'>❌ Error creating dealer summary: {str(e)}</div>" 

ui/__init__.py

@@ -0,0 +1 @@
+# UI components for the Swiper Match Gradio application 

ui/interface.py

@@ -0,0 +1,127 @@
+"""
+Interface functions for the Gradio application
+Contains all the functions that connect the UI to the business logic
+"""
+
+import gradio as gr
+import pandas as pd
+from core.config import MAKE_MODEL_DATA
+
+
+def update_models(make):
+    """Update model choices based on selected make"""
+    if make in MAKE_MODEL_DATA:
+        models = MAKE_MODEL_DATA[make]
+        return gr.Dropdown(choices=models, value=models[0] if models else None)
+    else:
+        return gr.Dropdown(choices=[], value=None)
+
+
+def predict_dealers_interface(matcher, make, model, year, body_type, fuel_type, transmission, 
+                            odometer, doors, seats, engine_size, power, cylinders,
+                            safety_rating, drive_type, segment, condition, selected_model):
+    """Interface function for detailed Gradio prediction"""
+    return matcher.predict_dealers(make, model, year, body_type, fuel_type, transmission,
+                                 odometer, doors, seats, engine_size, power, cylinders,
+                                 safety_rating, drive_type, segment, condition, selected_model)
+
+
+def simple_predict_dealers_interface(matcher, simple_make, simple_model, simple_year, 
+                                   simple_odometer, simple_model_selection):
+    """Simple interface function for Gradio with conditional parameters"""
+    
+    return matcher.predict_dealers(
+        make=simple_make, 
+        model=simple_model, 
+        year=simple_year, 
+        body_type=None,
+        fuel_type=None,
+        transmission=None,
+        odometer=simple_odometer, 
+        doors=None,
+        seats=None,
+        engine_size=None,
+        power=None,
+        cylinders=None,
+        safety_rating=None,
+        drive_type=None,
+        segment=None,
+        condition=None,
+        selected_model=simple_model_selection
+    )
+
+
+def search_data_interface(matcher, make, model, year_value, year_range, body_type, fuel_type, 
+                         odometer_value, odometer_range, max_price, selected_file, max_results, show_dealer_stats):
+    """Interface function for traditional data search"""
+    message, result_data = matcher.search_data_files(make, model, year_min=None, year_max=None,
+                                                     year_value=year_value, year_range=year_range,
+                                                     body_type=body_type, fuel_type=fuel_type, max_odometer=None,
+                                                     odometer_value=odometer_value, odometer_range=odometer_range,
+                                                     max_price=max_price, selected_file=selected_file, 
+                                                     max_results=max_results, show_dealer_stats=show_dealer_stats)
+    
+    if isinstance(result_data, pd.DataFrame) and result_data.empty:
+        return message, "No results to display", ""
+    elif isinstance(result_data, str):  # HTML from _create_dealer_summary
+        # Extract stats for info display
+        if "Top dealer:" in message:
+            info_text = f"**🏆 Dealer Rankings with Expandable Car Lists**\n\n"
+            info_text += "Click on any dealer name to see their individual car listings with prices and specifications."
+        else:
+            info_text = f"**📊 Search completed successfully**\n\n"
+        
+        return message, info_text, result_data
+    else:
+        # Handle DataFrame case (when show_dealer_stats=False)
+        if hasattr(result_data, 'empty') and not result_data.empty:
+            info_text = f"**📊 Search completed successfully**\n\n"
+            html_table = result_data.to_html(classes='table table-striped', 
+                                           table_id='search-results', escape=False, index=False)
+            return message, info_text, html_table
+        else:
+            return message, "No results to display", ""
+
+
+def simple_search_data_interface(matcher, make, model, year_value, year_range, odometer_value, odometer_range, selected_file, 
+                                max_results, show_dealer_stats):
+    """Interface function for simple traditional data search"""
+    
+    message, result_data = matcher.search_data_files(
+        make=make, 
+        model=model, 
+        year_min=None, 
+        year_max=None,
+        year_value=year_value,
+        year_range=year_range,
+        body_type=None,  # Not used in simple search
+        fuel_type=None,  # Not used in simple search
+        max_odometer=None,  # Not using max_odometer anymore
+        odometer_value=odometer_value,
+        odometer_range=odometer_range,
+        max_price=None,  # Not used in simple search
+        selected_file=selected_file, 
+        max_results=max_results, 
+        show_dealer_stats=show_dealer_stats
+    )
+    
+    if isinstance(result_data, pd.DataFrame) and result_data.empty:
+        return message, "No results to display", ""
+    elif isinstance(result_data, str):  # HTML from _create_dealer_summary
+        # Extract stats for info display
+        if "Top dealer:" in message:
+            info_text = f"**🏆 Dealer Rankings with Expandable Car Lists**\n\n"
+            info_text += "Click on any dealer name to see their individual car listings with prices and specifications."
+        else:
+            info_text = f"**📊 Search completed successfully**\n\n"
+        
+        return message, info_text, result_data
+    else:
+        # Handle DataFrame case (when show_dealer_stats=False)
+        if hasattr(result_data, 'empty') and not result_data.empty:
+            info_text = f"**📊 Search completed successfully**\n\n"
+            html_table = result_data.to_html(classes='table table-striped', 
+                                           table_id='search-results', escape=False, index=False)
+            return message, info_text, html_table
+        else:
+            return message, "No results to display", "" 

ui/tabs/__init__.py

@@ -0,0 +1 @@
+# Tab components for the Gradio interface 

ui/tabs/detailed_tab.py

@@ -0,0 +1,186 @@
+"""
+Detailed tab component for advanced car dealer search
+"""
+
+import gradio as gr
+from core.config import (
+    CAR_MAKES, MAKE_MODEL_DATA, BODY_TYPES, FUEL_TYPES, TRANSMISSION_TYPES,
+    DRIVE_TYPES, SEGMENTS, CONDITIONS, DEFAULT_VALUES
+)
+
+
+def create_detailed_tab(matcher):
+    """Create the detailed prediction tab"""
+    
+    with gr.Tab("⚙️ Detailed ML Search"):
+        gr.Markdown("### Advanced Car Dealer Search")
+        gr.Markdown("Specify detailed vehicle characteristics for more precise recommendations")
+        
+        # Model Selection Section
+        with gr.Row():
+            model_selection = gr.Dropdown(
+                choices=matcher.available_models if matcher.model_loaded else ['Model not loaded'],
+                label="🤖 Select AI Model",
+                value=matcher.available_models[0] if matcher.available_models else 'Model not loaded',
+                info="WeightedEnsemble_L3 provides the best overall performance",
+                scale=2
+            )
+            
+            with gr.Column(scale=1):
+                gr.Markdown("""
+                **Available Models:**
+                - **WeightedEnsemble**: Best performance (combines all models)
+                - **RandomForest**: Tree-based, interpretable
+                - **XGBoost**: Gradient boosting, fast
+                - **NeuralNet**: Deep learning, complex patterns
+                """)
+        
+        with gr.Row():
+            # Basic Vehicle Info
+            with gr.Column(scale=1):
+                gr.Markdown("### 🚗 Basic Vehicle Information")
+                
+                make = gr.Dropdown(
+                    choices=CAR_MAKES, 
+                    label="Make", 
+                    value=DEFAULT_VALUES['make']
+                )
+                model = gr.Dropdown(
+                    choices=MAKE_MODEL_DATA[DEFAULT_VALUES['make']], 
+                    label="Model", 
+                    value=DEFAULT_VALUES['model']
+                )
+                year = gr.Number(
+                    label="Year", 
+                    value=DEFAULT_VALUES['year'], 
+                    minimum=1990, 
+                    maximum=2025
+                )
+                condition = gr.Dropdown(
+                    choices=CONDITIONS, 
+                    label="Condition", 
+                    value=DEFAULT_VALUES['condition']
+                )
+                
+            # Body & Style
+            with gr.Column(scale=1):
+                gr.Markdown("### 🏗️ Body & Style")
+                
+                body_type = gr.Dropdown(
+                    choices=BODY_TYPES, 
+                    label="Body Type", 
+                    value=DEFAULT_VALUES['body_type']
+                )
+                segment = gr.Dropdown(
+                    choices=SEGMENTS, 
+                    label="Vehicle Segment", 
+                    value=DEFAULT_VALUES['segment']
+                )
+                doors = gr.Number(
+                    label="Doors", 
+                    value=DEFAULT_VALUES['doors'], 
+                    minimum=2, 
+                    maximum=6
+                )
+                seats = gr.Number(
+                    label="Seats", 
+                    value=DEFAULT_VALUES['seats'], 
+                    minimum=2, 
+                    maximum=9
+                )
+                
+            # Engine & Performance  
+            with gr.Column(scale=1):
+                gr.Markdown("### ⚡ Engine & Performance")
+                
+                fuel_type = gr.Dropdown(
+                    choices=FUEL_TYPES, 
+                    label="Fuel Type", 
+                    value=DEFAULT_VALUES['fuel_type']
+                )
+                transmission = gr.Dropdown(
+                    choices=TRANSMISSION_TYPES, 
+                    label="Transmission", 
+                    value=DEFAULT_VALUES['transmission']
+                )
+                engine_size = gr.Number(
+                    label="Engine Size (L)", 
+                    value=DEFAULT_VALUES['engine_size'], 
+                    minimum=0.5, 
+                    maximum=8.0
+                )
+                cylinders = gr.Number(
+                    label="Cylinders", 
+                    value=DEFAULT_VALUES['cylinders'], 
+                    minimum=2, 
+                    maximum=12
+                )
+        
+        with gr.Row():
+            # Technical Details
+            with gr.Column(scale=1):
+                gr.Markdown("### 🔧 Technical Details")
+                
+                power = gr.Number(
+                    label="Power (HP)", 
+                    value=DEFAULT_VALUES['power'], 
+                    minimum=50, 
+                    maximum=1000
+                )
+                drive_type = gr.Dropdown(
+                    choices=DRIVE_TYPES, 
+                    label="Drive Type", 
+                    value=DEFAULT_VALUES['drive_type']
+                )
+                safety_rating = gr.Number(
+                    label="Safety Rating (1-5)", 
+                    value=DEFAULT_VALUES['safety_rating'], 
+                    minimum=1, 
+                    maximum=5
+                )
+                
+            # Usage & History
+            with gr.Column(scale=1):
+                gr.Markdown("### 📊 Usage & History")
+                
+                odometer = gr.Number(
+                    label="Odometer (km)", 
+                    value=DEFAULT_VALUES['odometer'], 
+                    minimum=0
+                )
+                
+        # Detailed prediction button
+        predict_btn = gr.Button(
+            "🎯 Find Best Dealers (Detailed)",
+            variant="primary",
+            size="lg"
+        )
+        
+        # Detailed Results Section
+        with gr.Row():
+            with gr.Column(scale=1):
+                top_dealer = gr.Textbox(
+                    label="🏆 Top Recommended Dealer",
+                    interactive=False,
+                    lines=2
+                )
+                confidence = gr.Textbox(
+                    label="🎯 Confidence Score",
+                    interactive=False,
+                    lines=1
+                )
+            with gr.Column(scale=2):
+                detailed_results = gr.Markdown(
+                    label="📊 Detailed Results",
+                    value="Click 'Find Best Dealers (Detailed)' to see AI recommendations..."
+                )
+    
+    return {
+        'inputs': [make, model, year, body_type, fuel_type, transmission, 
+                  odometer, doors, seats, engine_size, power, cylinders,
+                  safety_rating, drive_type, segment, condition, model_selection],
+        'outputs': [top_dealer, confidence, detailed_results],
+        'button': predict_btn,
+        'make_dropdown': make,
+        'model_dropdown': model
+    } 

ui/tabs/simple_search_tab.py

@@ -0,0 +1,138 @@
+"""
+Simple search tab component for quick CSV data search
+"""
+
+import gradio as gr
+from core.config import CAR_MAKES, MAKE_MODEL_DATA, DEFAULT_VALUES
+
+
+def create_simple_search_tab(matcher):
+    """Create the simple traditional search tab"""
+    
+    with gr.Tab("🔍 Traditional Simple Search"):
+        gr.Markdown("### Quick CSV Data Search")
+        gr.Markdown("Simple search through car listing CSV files with basic filters")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 🗂️ File & Options")
+                simple_search_file = gr.Dropdown(
+                    choices=matcher.data_files,
+                    label="Select CSV File",
+                    value=matcher.data_files[0] if matcher.data_files else None,
+                    info=f"Available files: {len(matcher.data_files)}"
+                )
+                
+                simple_max_results = gr.Number(
+                    label="Max Results",
+                    value=DEFAULT_VALUES['max_results'],
+                    minimum=1,
+                    maximum=1000,
+                    info="Limit number of results returned"
+                )
+                
+                simple_show_dealer_stats = gr.Checkbox(
+                    label="📊 Show Dealer Rankings",
+                    value=True,
+                    info="Rank dealers by number of matching cars"
+                )
+            
+            with gr.Column(scale=2):
+                gr.Markdown("### 🔍 Basic Search Filters")
+                
+                with gr.Row():
+                    simple_search_make = gr.Dropdown(
+                        choices=CAR_MAKES, 
+                        label="Make", 
+                        value=DEFAULT_VALUES['make'],
+                        info="Select car manufacturer"
+                    )
+                    simple_search_model = gr.Dropdown(
+                        choices=MAKE_MODEL_DATA[DEFAULT_VALUES['make']], 
+                        label="Model", 
+                        value=DEFAULT_VALUES['model'],
+                        info="Select car model"
+                    )
+                
+                with gr.Row():
+                    simple_year_value = gr.Number(
+                        label="Target Year",
+                        value=DEFAULT_VALUES['year'],
+                        minimum=1990,
+                        maximum=2025,
+                        info="Target manufacturing year"
+                    )
+                    simple_year_range = gr.Slider(
+                        minimum=0,
+                        maximum=8,
+                        value=1,
+                        step=1,
+                        label="Year Range (±years)",
+                        info="Range around target year"
+                    )
+                
+                with gr.Row():
+                    simple_odometer_value = gr.Number(
+                        label="Target Odometer (km)",
+                        value=65000,
+                        minimum=0,
+                        info="Target odometer reading"
+                    )
+                    simple_odometer_range = gr.Slider(
+                        minimum=0,
+                        maximum=100000,
+                        value=20000,
+                        step=1000,
+                        label="Odometer Range (±km)",
+                        info="Range around target (±km)"
+                    )
+        
+        # Simple traditional search button
+        simple_search_btn = gr.Button(
+            "🔍 Search CSV Data (Simple)",
+            variant="primary",
+            size="lg"
+        )
+        
+        # Simple Traditional Search Results Section
+        with gr.Row():
+            simple_search_status = gr.Textbox(
+                label="🔍 Search Status",
+                interactive=False,
+                lines=2
+            )
+        
+        with gr.Row():
+            simple_search_info = gr.Markdown(
+                label="📊 Results Info",
+                value="Click 'Search CSV Data (Simple)' to start searching..."
+            )
+        
+        with gr.Row():
+            simple_search_results_table = gr.HTML(
+                label="📋 Search Results",
+                value="<p>No search performed yet</p>"
+            )
+        
+        gr.Markdown("""
+        ---
+        ### 🎯 Simple Search Features
+        
+        **Quick Setup:** Just select make, model, target year ± range, and odometer target ± range
+        **Smart Defaults:** Pre-filled with popular choices
+        **🎯 Year Range:** Set target year with ± range (e.g., 2020 ± 1 year = 2019-2021)
+        **🎯 Odometer Range:** Set target odometer reading with ± range (e.g., 65,000 ± 20,000 km)
+        **Same Power:** Uses the same CSV search engine as Traditional Search
+        **Dealer Ranking:** Get dealers ranked by inventory matching your criteria
+        **Fast Results:** Simplified interface for quicker searches
+        """)
+    
+    return {
+        'inputs': [simple_search_make, simple_search_model, simple_year_value, simple_year_range, 
+                  simple_odometer_value, simple_odometer_range, simple_search_file, simple_max_results, 
+                  simple_show_dealer_stats],
+        'outputs': [simple_search_status, simple_search_info, simple_search_results_table],
+        'button': simple_search_btn,
+        'make_dropdown': simple_search_make,
+        'model_dropdown': simple_search_model
+    } 

ui/tabs/simple_tab.py

@@ -0,0 +1,83 @@
+"""
+Simple tab component for quick car dealer search
+"""
+
+import gradio as gr
+from core.config import CAR_MAKES, MAKE_MODEL_DATA, DEFAULT_VALUES
+
+
+def create_simple_tab(simple_matcher):
+    """Create the simple prediction tab"""
+    
+    with gr.Tab("🔍 Simple ML Search"):
+        gr.Markdown("### Quick Car Dealer Search")
+        gr.Markdown("Enter just the basic details for a quick recommendation")
+        
+        # Model Selection for Simple Tab
+        simple_model_selection = gr.Dropdown(
+            choices=simple_matcher.available_models if simple_matcher.model_loaded else ['Model not loaded'],
+            label="🤖 Select AI Model",
+            value=simple_matcher.available_models[0] if simple_matcher.available_models else 'Model not loaded',
+            info="WeightedEnsemble_L3 provides the best overall performance"
+        )
+        
+        with gr.Row():
+            # Basic inputs
+            with gr.Column(scale=1):
+                simple_make = gr.Dropdown(
+                    choices=CAR_MAKES, 
+                    label="Make", 
+                    value=DEFAULT_VALUES['make']
+                )
+                simple_model = gr.Dropdown(
+                    choices=MAKE_MODEL_DATA[DEFAULT_VALUES['make']], 
+                    label="Model", 
+                    value=DEFAULT_VALUES['model']
+                )
+                
+            with gr.Column(scale=1):
+                simple_year = gr.Number(
+                    label="Year", 
+                    value=DEFAULT_VALUES['year'], 
+                    minimum=1990, 
+                    maximum=2025
+                )
+                simple_odometer = gr.Number(
+                    label="Odometer (km)", 
+                    value=DEFAULT_VALUES['odometer'], 
+                    minimum=0
+                )
+        
+        # Simple prediction button
+        simple_predict_btn = gr.Button(
+            "🎯 Find Best Dealers (Simple)",
+            variant="primary",
+            size="lg"
+        )
+        
+        # Simple Results Section
+        with gr.Row():
+            with gr.Column(scale=1):
+                simple_top_dealer = gr.Textbox(
+                    label="🏆 Top Recommended Dealer",
+                    interactive=False,
+                    lines=2
+                )
+                simple_confidence = gr.Textbox(
+                    label="🎯 Confidence Score",
+                    interactive=False,
+                    lines=1
+                )
+            with gr.Column(scale=2):
+                simple_detailed_results = gr.Markdown(
+                    label="📊 Results",
+                    value="Click 'Find Best Dealers (Simple)' to see recommendations..."
+                )
+    
+    return {
+        'inputs': [simple_make, simple_model, simple_year, simple_odometer, simple_model_selection],
+        'outputs': [simple_top_dealer, simple_confidence, simple_detailed_results],
+        'button': simple_predict_btn,
+        'make_dropdown': simple_make,
+        'model_dropdown': simple_model
+    } 

ui/tabs/traditional_tab.py

@@ -0,0 +1,174 @@
+"""
+Traditional search tab component for CSV data file search
+"""
+
+import gradio as gr
+from core.config import DEFAULT_VALUES
+
+
+def create_traditional_tab(matcher):
+    """Create the traditional search tab"""
+    
+    with gr.Tab("📊 Traditional Search"):
+        gr.Markdown("### CSV Data File Search")
+        gr.Markdown("Search through car listing CSV files and rank dealers by inventory size")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 🗂️ File Selection")
+                selected_file = gr.Dropdown(
+                    choices=matcher.data_files,
+                    label="Select CSV File",
+                    value=matcher.data_files[0] if matcher.data_files else None,
+                    info=f"Available files: {len(matcher.data_files)}"
+                )
+                
+                max_results = gr.Number(
+                    label="Max Results",
+                    value=DEFAULT_VALUES['max_results'],
+                    minimum=1,
+                    maximum=1000,
+                    info="Limit number of results returned"
+                )
+                
+                show_dealer_stats = gr.Checkbox(
+                    label="📊 Show Dealer Rankings",
+                    value=True,
+                    info="Rank dealers by number of matching cars"
+                )
+            
+            with gr.Column(scale=2):
+                gr.Markdown("### 🔍 Search Filters")
+                
+                with gr.Row():
+                    search_make = gr.Textbox(
+                        label="Make (contains)",
+                        placeholder="e.g., Toyota, Ford",
+                        info="Search for car manufacturer"
+                    )
+                    search_model = gr.Textbox(
+                        label="Model (contains)",
+                        placeholder="e.g., Camry, Focus",
+                        info="Search for car model"
+                    )
+                
+                with gr.Row():
+                    year_value = gr.Number(
+                        label="Target Year",
+                        value=DEFAULT_VALUES['year'],
+                        minimum=1980,
+                        maximum=2025,
+                        info="Target manufacturing year"
+                    )
+                    year_range = gr.Slider(
+                        minimum=0,
+                        maximum=10,
+                        value=2,
+                        step=1,
+                        label="Year Range (±years)",
+                        info="Range around target year (e.g., ±2 years)"
+                    )
+                
+                with gr.Row():
+                    search_body_type = gr.Textbox(
+                        label="Body Type (contains)",
+                        placeholder="e.g., sedan, suv, hatch",
+                        info="Vehicle body style"
+                    )
+                    search_fuel_type = gr.Textbox(
+                        label="Fuel Type (contains)",
+                        placeholder="e.g., petrol, diesel, electric",
+                        info="Fuel/energy type"
+                    )
+                
+                with gr.Row():
+                    odometer_value = gr.Number(
+                        label="Target Odometer (km)",
+                        value=75000,
+                        minimum=0,
+                        info="Target odometer reading (center value)"
+                    )
+                    odometer_range = gr.Slider(
+                        minimum=0,
+                        maximum=100000,
+                        value=25000,
+                        step=1000,
+                        label="Odometer Range (±km)",
+                        info="Range around target (e.g., ±25,000 km)"
+                    )
+                
+                with gr.Row():
+                    max_price = gr.Number(
+                        label="Max Price (AUD)",
+                        minimum=0,
+                        info="Maximum advertised price"
+                    )
+        
+        # Traditional search button
+        search_btn = gr.Button(
+            "🔍 Search CSV Data",
+            variant="primary",
+            size="lg"
+        )
+        
+        # Traditional Search Results Section
+        with gr.Row():
+            search_status = gr.Textbox(
+                label="🔍 Search Status",
+                interactive=False,
+                lines=2
+            )
+        
+        with gr.Row():
+            search_info = gr.Markdown(
+                label="📊 Results Info",
+                value="Click 'Search CSV Data' to start searching..."
+            )
+        
+        with gr.Row():
+            search_results_table = gr.HTML(
+                label="📋 Search Results",
+                value="<p>No search performed yet</p>"
+            )
+        
+        # Data file info section
+        gr.Markdown(f"""
+        ---
+        ### 📁 Available Data Files
+        
+        **Files Found:** {len(matcher.data_files)}
+        
+        **File List:**
+        {chr(10).join([f'• {file}' for file in matcher.data_files]) if matcher.data_files else '• No CSV files found in ./data directory'}
+        
+        ### 🔍 Search Features
+        
+        **📊 Dealer Ranking:** Dealers ranked by number of cars matching your criteria
+        **🏆 Inventory Priority:** Dealers with more matching inventory appear first
+        **🎯 Year Range Search:** Set target year ± range (e.g., 2020 ± 2 years = 2018-2022)
+        **🎯 Odometer Range Search:** Set target odometer value ± range (e.g., 75,000 ± 25,000 km = 50,000-100,000 km)
+        **📈 Column Mapping:** Uses actual dataset columns:
+        - **Make/Model:** `make`, `model`
+        - **Year:** `manu_year` (searchable by target ± range)
+        - **Body Type:** `vehicle_body_type`
+        - **Fuel Type:** `vehicle_fuel_type`
+        - **Transmission:** `vehicle_transmission_type`
+        - **Mileage:** `odometer` (searchable by target ± range)
+        - **Price:** `advertised_price`
+        - **Dealer:** `dealer_trading_name`
+        - **Location:** `dealer_city`, `dealer_state`
+        
+        ### 📊 Dealer Ranking System
+        
+        **How it works:** Counts how many cars each dealer has that match your search criteria
+        **Ranking Logic:** Dealers with more matching cars get better ranks (Rank 1 = most inventory)
+        **Sorting:** Results sorted by dealer inventory count first, then by price
+        **Performance:** Fast counting using pandas group operations
+        """)
+    
+    return {
+        'inputs': [search_make, search_model, year_value, year_range, search_body_type, 
+                  search_fuel_type, odometer_value, odometer_range, max_price, selected_file, max_results, show_dealer_stats],
+        'outputs': [search_status, search_info, search_results_table],
+        'button': search_btn
+    } 

utils/__init__.py

@@ -0,0 +1 @@
+# Utility functions for the Swiper Match application 

utils/helpers.py

@@ -0,0 +1,109 @@
+"""
+Helper utility functions for the Swiper Match application
+"""
+
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def get_model_status_info(matcher, simple_matcher):
+    """Generate model status information for the footer"""
+    detailed_status_emoji = "✅" if matcher.model_loaded else "❌"
+    simple_status_emoji = "✅" if simple_matcher.model_loaded else "❌"
+    
+    return f"""
+    ### 📊 Model Information
+    
+    #### 🔧 **Detailed Model** (Advanced Search)
+    **Status:** {detailed_status_emoji} {"Model Loaded Successfully" if matcher.model_loaded else "Model Not Available"}  
+    **Path:** ./autogluon_model  
+    **Trained Dealers:** {len(matcher.trained_dealers) if matcher.model_loaded else "N/A"}  
+    **Available Models:** {len(matcher.available_models) if matcher.model_loaded else "N/A"} ({', '.join(matcher.available_models[:3]) + ('...' if len(matcher.available_models) > 3 else '') if matcher.model_loaded and matcher.available_models else "N/A"})  
+    **Features:** 23 vehicle specifications (no pricing data)  
+    
+    #### 🔍 **Simple Model** (Quick Search)  
+    **Status:** {simple_status_emoji} {"Model Loaded Successfully" if simple_matcher.model_loaded else "Model Not Available"}  
+    **Path:** ./simple_autogluon_models  
+    **Trained Dealers:** {len(simple_matcher.trained_dealers) if simple_matcher.model_loaded else "N/A"}  
+    **Available Models:** {len(simple_matcher.available_models) if simple_matcher.model_loaded else "N/A"} ({', '.join(simple_matcher.available_models[:3]) + ('...' if len(simple_matcher.available_models) > 3 else '') if simple_matcher.model_loaded and simple_matcher.available_models else "N/A"})  
+    **Features:** Subset of vehicle specifications for faster inference  
+    
+    #### 🤖 **Architecture**
+    **Framework:** AutoGluon TabularPredictor  
+    **Ensemble Learning:** Multiple algorithms combined via weighted voting  
+    **Algorithms:** RandomForest, XGBoost, NeuralNetTorch, CatBoost, LightGBM  
+    **Task:** Multi-class classification for dealer prediction
+    """
+
+
+def get_app_header():
+    """Generate the main application header"""
+    return """
+    # 🚗 Swiper Match - Car Dealer Predictor
+    ### AI-Powered Dealer Matching Based on Vehicle Specifications
+    Find the perfect dealer for your dream car using machine learning
+    """
+
+
+def get_app_description():
+    """Generate the application description"""
+    return """
+    **🎯 How it works:** This tool analyzes vehicle specifications to predict which dealers are most likely to have cars matching your preferences. The model focuses on technical specifications, not pricing.
+    """
+
+
+def setup_event_handlers(tabs_data, interface_functions, matchers):
+    """Setup event handlers for all tabs"""
+    simple_tab, detailed_tab, traditional_tab, simple_search_tab = tabs_data
+    matcher, simple_matcher = matchers
+    
+    # Simple tab click event
+    simple_tab['button'].click(
+        fn=lambda *args: interface_functions['simple_predict'](simple_matcher, *args),
+        inputs=simple_tab['inputs'],
+        outputs=simple_tab['outputs']
+    )
+    
+    # Detailed tab click event
+    detailed_tab['button'].click(
+        fn=lambda *args: interface_functions['predict'](matcher, *args),
+        inputs=detailed_tab['inputs'],
+        outputs=detailed_tab['outputs']
+    )
+    
+    # Traditional search click event
+    traditional_tab['button'].click(
+        fn=lambda *args: interface_functions['search'](matcher, *args),
+        inputs=traditional_tab['inputs'],
+        outputs=traditional_tab['outputs']
+    )
+    
+    # Simple traditional search click event
+    simple_search_tab['button'].click(
+        fn=lambda *args: interface_functions['simple_search'](matcher, *args),
+        inputs=simple_search_tab['inputs'],
+        outputs=simple_search_tab['outputs']
+    )
+    
+    # Set up dynamic model updating based on make selection
+    simple_tab['make_dropdown'].change(
+        fn=interface_functions['update_models'],
+        inputs=simple_tab['make_dropdown'],
+        outputs=simple_tab['model_dropdown']
+    )
+    
+    detailed_tab['make_dropdown'].change(
+        fn=interface_functions['update_models'],
+        inputs=detailed_tab['make_dropdown'],
+        outputs=detailed_tab['model_dropdown']
+    )
+    
+    # Simple traditional search make/model update
+    simple_search_tab['make_dropdown'].change(
+        fn=interface_functions['update_models'],
+        inputs=simple_search_tab['make_dropdown'],
+        outputs=simple_search_tab['model_dropdown']
+    )