added phone numbers to results

app.py

@@ -13,12 +13,13 @@ from core.config import DETAILED_MODEL_PATH, SIMPLE_MODEL_PATH, UI_CONFIG, GRADI
 # Import UI components
 from ui.interface import (
     update_models, predict_dealers_interface, simple_predict_dealers_interface,
-    search_data_interface, simple_search_data_interface
+    search_data_interface, simple_search_data_interface, range_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
+from ui.tabs.range_search_tab import create_range_search_tab
 
 # Import utilities
 from utils.helpers import get_model_status_info, get_app_header, get_app_description, setup_event_handlers
@@ -50,6 +51,7 @@ def create_app():
         # Create tabs
         with gr.Tabs():
             simple_search_tab = create_simple_search_tab(matcher)
+            range_search_tab = create_range_search_tab(matcher)
             traditional_tab = create_traditional_tab(matcher)
             simple_tab = create_simple_tab(simple_matcher)
             detailed_tab = create_detailed_tab(matcher)
@@ -64,10 +66,11 @@ def create_app():
             'predict': predict_dealers_interface,
             'simple_predict': simple_predict_dealers_interface,
             'search': search_data_interface,
-            'simple_search': simple_search_data_interface
+            'simple_search': simple_search_data_interface,
+            'simple_range_search': range_search_data_interface
         }
         
-        tabs_data = (simple_tab, detailed_tab, traditional_tab, simple_search_tab)
+        tabs_data = (simple_tab, detailed_tab, traditional_tab, simple_search_tab, range_search_tab)
         matchers = (matcher, simple_matcher)
         
         setup_event_handlers(tabs_data, interface_functions, matchers)

core/__init__.py

@@ -1 +1,24 @@
-# Core modules for the Swiper Match application 
+"""
+Core modules for the Swiper Match application
+Contains the main business logic and configuration
+"""
+
+# Import core components
+from .matcher import CarDealerMatcher
+from .config import (
+    DETAILED_MODEL_PATH,
+    SIMPLE_MODEL_PATH, 
+    UI_CONFIG,
+    GRADIO_CSS,
+    MAKE_MODEL_DATA
+)
+
+# Define what gets exported when using "from core import *"
+__all__ = [
+    'CarDealerMatcher',
+    'DETAILED_MODEL_PATH',
+    'SIMPLE_MODEL_PATH',
+    'UI_CONFIG', 
+    'GRADIO_CSS',
+    'MAKE_MODEL_DATA'
+] 

core/matcher.py

@@ -258,15 +258,32 @@ class CarDealerMatcher:
             # Sort by probability and get top 5
             sorted_dealers = sorted(proba_dict.items(), key=lambda x: x[1], reverse=True)[:5]
             
+            # Get all dealer names for batch contact lookup
+            dealer_names = [dealer[0] for dealer in sorted_dealers]
+            all_contacts = self.get_dealers_contact_info_batch(dealer_names)
+            
             # Create structured JSON response
             dealer_predictions = []
             for i, (dealer, prob) in enumerate(sorted_dealers, 1):
-                dealer_predictions.append({
+                # Get contact information from batch lookup
+                contact_info = all_contacts.get(dealer)
+                
+                dealer_prediction = {
                     "rank": i,
                     "dealer_name": dealer,
                     "confidence_score": round(prob, 4),
                     "confidence_percentage": f"{prob:.2%}"
-                })
+                }
+                
+                # Add contact information if available
+                if contact_info:
+                    dealer_prediction["contact"] = {
+                        "phone": contact_info.get('phone'),
+                        "city": contact_info.get('city'),
+                        "state": contact_info.get('state')
+                    }
+                
+                dealer_predictions.append(dealer_prediction)
             
             # Create vehicle input summary
             vehicle_input = {
@@ -291,14 +308,27 @@ class CarDealerMatcher:
             # Remove None values from vehicle input
             vehicle_input = {k: v for k, v in vehicle_input.items() if v is not None}
             
+            # Get contact info for top dealer from batch lookup
+            top_dealer_contact = all_contacts.get(sorted_dealers[0][0])
+            
+            top_dealer_info = {
+                "name": sorted_dealers[0][0],
+                "confidence_score": round(sorted_dealers[0][1], 4),
+                "confidence_percentage": f"{sorted_dealers[0][1]:.2%}"
+            }
+            
+            # Add contact information for top dealer
+            if top_dealer_contact:
+                top_dealer_info["contact"] = {
+                    "phone": top_dealer_contact.get('phone'),
+                    "city": top_dealer_contact.get('city'),
+                    "state": top_dealer_contact.get('state')
+                }
+            
             return {
                 "success": True,
                 "data": {
-                    "top_dealer": {
-                        "name": sorted_dealers[0][0],
-                        "confidence_score": round(sorted_dealers[0][1], 4),
-                        "confidence_percentage": f"{sorted_dealers[0][1]:.2%}"
-                    },
+                    "top_dealer": top_dealer_info,
                     "dealer_rankings": dealer_predictions,
                     "model_info": {
                         "model_used": model_used,
@@ -589,8 +619,17 @@ class CarDealerMatcher:
             
             # 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
+                dealer_summary_data = self._create_dealer_summary(df)
+                
+                # Import the HTML formatting utility here to avoid circular imports
+                try:
+                    from utils import format_dealer_results_as_html
+                    dealer_summary_html = format_dealer_results_as_html(dealer_summary_data)
+                    return f"✅ Found {filtered_count:,} matches from {original_count:,} records in {file_to_search}", dealer_summary_html
+                except ImportError:
+                    # Fallback if import fails
+                    logger.warning("Could not import HTML formatting utility, returning raw data")
+                    return f"✅ Found {filtered_count:,} matches from {original_count:,} records in {file_to_search}", dealer_summary_data
             else:
                 # Return basic summary without dealer rankings
                 summary_df = pd.DataFrame({
@@ -604,7 +643,7 @@ class CarDealerMatcher:
             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"""
+        """Create dealer ranking summary with structured data (API-friendly)"""
         try:
             logger.info(f"📊 Creating dealer summary from {len(df)} matching cars...")
             
@@ -614,78 +653,329 @@ class CarDealerMatcher:
             # 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 = ""
+            dealer_results = []
             
             # 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}"
+                # Extract contact information directly from the first car record for this dealer
+                first_car = dealer_cars.iloc[0]
+                contact_info = {
+                    'phone': None,
+                    'city': first_car.get('dealer_city', 'Unknown'),
+                    'state': first_car.get('dealer_state', 'Unknown')
+                }
+                
+                # Try to get phone number from available phone fields in the data
+                phone_fields = ['dealer_phone_lead', 'dealer_phone_lead_at', 'dealer_phone_lead_cg']
+                for field in phone_fields:
+                    if field in first_car and pd.notna(first_car[field]):
+                        contact_info['phone'] = str(first_car[field]).strip()
+                        break
+                
+                # Convert cars to structured format (limit to 20 for performance)
+                cars_list = []
+                for _, car in dealer_cars.head(20).iterrows():
+                    car_data = {
+                        'make': car.get('make', 'Unknown'),
+                        'model': car.get('model', 'Unknown'),
+                        'year': car.get('manu_year', 'Unknown'),
+                        'price': car.get('advertised_price', 'Unknown'),
+                        'odometer': car.get('odometer', 'Unknown'),
+                        'body_type': car.get('vehicle_body_type', 'Unknown'),
+                        'fuel_type': car.get('vehicle_fuel_type', 'Unknown'),
+                        'transmission': car.get('vehicle_transmission_type', 'Unknown')
+                    }
+                    cars_list.append(car_data)
                 
-                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;">
-                """
+                dealer_result = {
+                    'rank': rank,
+                    'dealer_name': dealer_name,
+                    'car_count': int(car_count),
+                    'contact': contact_info,
+                    'cars': cars_list,
+                    'total_cars': len(dealer_cars)  # Include total count for "show more" logic
+                }
                 
-                # 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')
+                dealer_results.append(dealer_result)
+            
+            logger.info(f"✅ Created dealer summary. Top dealer: {top_dealers.index[0]} with {top_dealers.iloc[0]} cars")
+            return dealer_results
+            
+        except Exception as e:
+            logger.error(f"❌ Error creating dealer summary: {e}")
+            return []
+
+    def get_dealer_contact_info(self, dealer_name):
+        """Look up dealer contact information from CSV data files"""
+        try:
+            if not self.data_files:
+                return None
+            
+            # Use the first available data file (Combined file should have all dealer info)
+            file_to_search = self.data_files[0]
+            file_path = os.path.join(DATA_DIR, 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()
+            
+            # Find dealer by name
+            if 'dealer_trading_name' in df.columns:
+                dealer_matches = df[df['dealer_trading_name'].astype(str).str.contains(dealer_name, case=False, na=False)]
+                
+                if not dealer_matches.empty:
+                    # Get the first match
+                    dealer_info = dealer_matches.iloc[0]
                     
-                    # 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"
+                    # Extract contact information
+                    contact_info = {
+                        'dealer_name': dealer_info.get('dealer_trading_name', dealer_name),
+                        'phone': None,
+                        'city': dealer_info.get('dealer_city', 'Unknown'),
+                        'state': dealer_info.get('dealer_state', 'Unknown')
+                    }
                     
-                    # 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"
+                    # Try to get phone number from available phone fields
+                    phone_fields = ['dealer_phone_lead', 'dealer_phone_lead_at', 'dealer_phone_lead_cg']
+                    for field in phone_fields:
+                        if field in dealer_info and pd.notna(dealer_info[field]):
+                            contact_info['phone'] = str(dealer_info[field]).strip()
+                            break
                     
-                    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>
-                    """
+                    return contact_info
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"❌ Error looking up dealer contact info: {e}")
+            return None
+
+    def get_dealers_contact_info_batch(self, dealer_names):
+        """Look up contact information for multiple dealers efficiently in one pass"""
+        try:
+            if not self.data_files or not dealer_names:
+                return {}
+            
+            # Use the first available data file (Combined file should have all dealer info)
+            file_to_search = self.data_files[0]
+            file_path = os.path.join(DATA_DIR, file_to_search)
+            
+            # Read CSV with error handling for different encodings (only once)
+            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()
+            
+            contact_info_dict = {}
+            
+            # Find dealers by name in batch
+            if 'dealer_trading_name' in df.columns:
+                for dealer_name in dealer_names:
+                    dealer_matches = df[df['dealer_trading_name'].astype(str).str.contains(dealer_name, case=False, na=False)]
+                    
+                    if not dealer_matches.empty:
+                        # Get the first match
+                        dealer_info = dealer_matches.iloc[0]
+                        
+                        # Extract contact information
+                        contact_info = {
+                            'dealer_name': dealer_info.get('dealer_trading_name', dealer_name),
+                            'phone': None,
+                            'city': dealer_info.get('dealer_city', 'Unknown'),
+                            'state': dealer_info.get('dealer_state', 'Unknown')
+                        }
+                        
+                        # Try to get phone number from available phone fields
+                        phone_fields = ['dealer_phone_lead', 'dealer_phone_lead_at', 'dealer_phone_lead_cg']
+                        for field in phone_fields:
+                            if field in dealer_info and pd.notna(dealer_info[field]):
+                                contact_info['phone'] = str(dealer_info[field]).strip()
+                                break
+                        
+                        contact_info_dict[dealer_name] = contact_info
+            
+            return contact_info_dict
+            
+        except Exception as e:
+            logger.error(f"❌ Error looking up dealers contact info: {e}")
+            return {}
+
+    def search_data_files_api(self, keyword_search=None, make=None, model=None, year_min=None, year_max=None, 
+                             year_from=None, year_to=None,
+                             body_type=None, fuel_type=None, max_odometer=None, 
+                             odometer_from=None, odometer_to=None,
+                             max_price=None, selected_file=None, max_results=100):
+        """
+        Search through CSV data files and return clean structured data (API-friendly)
+        
+        Returns:
+            dict: {
+                "success": bool,
+                "message": str,
+                "data": {
+                    "search_summary": {
+                        "total_matches": int,
+                        "original_count": int,
+                        "file_searched": str
+                    },
+                    "dealers": [dealer_results_list]
+                }
+            }
+        """
+        try:
+            if not self.data_files:
+                return {
+                    "success": False,
+                    "message": "No CSV data files available",
+                    "data": None
+                }
+            
+            # 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 {
+                    "success": False,
+                    "message": "No valid file selected",
+                    "data": None
+                }
+            
+            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 the same filtering logic as search_data_files
+            # [Apply all the same filters here - keyword_search, make, model, etc.]
+            # ... (same filtering logic as in search_data_files)
+            
+            # Apply keyword search filter first (searches across multiple text columns)
+            if keyword_search and keyword_search.strip():
+                keyword = keyword_search.strip().lower()
+                
+                # Define text columns to search across
+                text_columns = ['make', 'model', 'dealer_trading_name', 'dealer_city', 'dealer_state', 
+                               'vehicle_body_type', 'vehicle_fuel_type', 'vehicle_transmission_type',
+                               'series', 'variant', 'vehicle_segment', 'vehicle_drive_type']
                 
-                # 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>
-                    """
+                # Filter to only existing columns
+                existing_text_columns = [col for col in text_columns if col in df.columns]
                 
-                html_content += """
-                    </div>
-                </details>
-                """
+                if existing_text_columns:
+                    # Create a combined search across all text columns
+                    # Convert to string first to handle non-string values
+                    keyword_mask = df[existing_text_columns[0]].astype(str).str.contains(keyword, case=False, na=False)
+                    
+                    for col in existing_text_columns[1:]:
+                        keyword_mask = keyword_mask | df[col].astype(str).str.contains(keyword, case=False, na=False)
+                    
+                    df = df[keyword_mask]
+                    logger.info(f"🔍 Keyword search '{keyword}' filtered to {len(df)} records")
             
-            logger.info(f"✅ Created dealer summary. Top dealer: {top_dealers.index[0]} with {top_dealers.iloc[0]} cars")
-            return html_content
+            # Apply specific filters using correct column names from the dataset
+            if make and 'make' in df.columns:
+                df = df[df['make'].astype(str).str.contains(make, case=False, na=False)]
+            
+            if model and 'model' in df.columns:
+                df = df[df['model'].astype(str).str.contains(model, case=False, na=False)]
+            
+            # Handle year filtering
+            if year_from is not None and year_to is not None and 'manu_year' in df.columns:
+                year_numeric = pd.to_numeric(df['manu_year'], errors='coerce')
+                df = df[(year_numeric >= year_from) & (year_numeric <= year_to)]
+            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'].astype(str).str.contains(body_type, case=False, na=False)]
+            
+            if fuel_type and 'vehicle_fuel_type' in df.columns:
+                df = df[df['vehicle_fuel_type'].astype(str).str.contains(fuel_type, case=False, na=False)]
+            
+            # Handle odometer filtering
+            if odometer_from is not None and odometer_to is not None and 'odometer' in df.columns:
+                odometer_numeric = pd.to_numeric(df['odometer'], errors='coerce')
+                df = df[(odometer_numeric >= odometer_from) & (odometer_numeric <= odometer_to)]
+            elif 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 {
+                    "success": True,
+                    "message": f"Searched {file_to_search} ({original_count:,} records) - No matches found",
+                    "data": {
+                        "search_summary": {
+                            "total_matches": 0,
+                            "original_count": original_count,
+                            "file_searched": file_to_search
+                        },
+                        "dealers": []
+                    }
+                }
+            
+            # Create dealer ranking summary (structured data)
+            dealer_results = []
+            if 'dealer_trading_name' in df.columns:
+                dealer_results = self._create_dealer_summary(df)
+            
+            return {
+                "success": True,
+                "message": f"Found {filtered_count:,} matches from {original_count:,} records in {file_to_search}",
+                "data": {
+                    "search_summary": {
+                        "total_matches": filtered_count,
+                        "original_count": original_count,
+                        "file_searched": file_to_search
+                    },
+                    "dealers": dealer_results
+                }
+            }
             
         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>" 
+            logger.error(f"❌ API search error: {e}")
+            return {
+                "success": False,
+                "message": f"Error searching data: {str(e)}",
+                "data": None
+            } 

ui/__init__.py

@@ -1 +1,41 @@
-# UI components for the Swiper Match Gradio application 
+"""
+UI components for the Swiper Match Gradio application
+"""
+
+# Import core interface functions
+from .interface import (
+    update_models,
+    predict_dealers_interface,
+    simple_predict_dealers_interface,
+    search_data_interface,
+    simple_search_data_interface,
+    range_search_data_interface,
+    range_search_data_interface_api,
+    search_data_interface_api,
+    simple_search_data_interface_api
+)
+
+# Import tab creation functions
+from .tabs.simple_tab import create_simple_tab
+from .tabs.detailed_tab import create_detailed_tab  
+from .tabs.traditional_tab import create_traditional_tab
+from .tabs.simple_search_tab import create_simple_search_tab
+from .tabs.range_search_tab import create_range_search_tab
+
+# Define what gets exported when using "from ui import *"
+__all__ = [
+    'update_models',
+    'predict_dealers_interface',
+    'simple_predict_dealers_interface', 
+    'search_data_interface',
+    'simple_search_data_interface',
+    'range_search_data_interface',
+    'range_search_data_interface_api',
+    'search_data_interface_api',
+    'simple_search_data_interface_api',
+    'create_simple_tab',
+    'create_detailed_tab',
+    'create_traditional_tab',
+    'create_simple_search_tab',
+    'create_range_search_tab'
+] 

ui/interface.py

@@ -80,6 +80,23 @@ def simple_predict_dealers_interface(matcher, simple_make, simple_model, simple_
     top_dealer = data["top_dealer"]["name"]
     confidence = data["top_dealer"]["confidence_percentage"]
     
+    # Get all dealer names for batch contact lookup
+    all_dealer_names = [dealer['dealer_name'] for dealer in data["dealer_rankings"]]
+    
+    # Batch lookup contact information for all dealers
+    all_contacts = matcher.get_dealers_contact_info_batch(all_dealer_names)
+    
+    # Get contact info for top dealer
+    top_dealer_contact = all_contacts.get(top_dealer)
+    
+    # Format top dealer info with contact details
+    if top_dealer_contact and top_dealer_contact.get('phone'):
+        top_dealer_display = f"🎯 **Best Match: {top_dealer}**\n📞 **Phone:** {top_dealer_contact['phone']}"
+        if top_dealer_contact.get('city') != 'Unknown' and top_dealer_contact.get('state') != 'Unknown':
+            top_dealer_display += f"\n📍 **Location:** {top_dealer_contact['city']}, {top_dealer_contact['state']}"
+    else:
+        top_dealer_display = f"🎯 **Best Match: {top_dealer}**\n📞 **Phone:** Contact dealer directly"
+    
     # Create user-friendly display with structured data
     display_text = f"""
 ## 🎯 **Prediction Results**
@@ -87,12 +104,34 @@ def simple_predict_dealers_interface(matcher, simple_make, simple_model, simple_
 ### 🏆 **Top Dealer**
 **{top_dealer}** - {confidence} confidence
 
-### 📊 **All Dealer Rankings**
 """
     
+    # Add contact information for top dealer
+    if top_dealer_contact:
+        display_text += f"""**📞 Phone:** {top_dealer_contact.get('phone', 'Contact dealer directly')}
+**📍 Location:** {top_dealer_contact.get('city', 'Unknown')}, {top_dealer_contact.get('state', 'Unknown')}
+
+"""
+    else:
+        display_text += "**📞 Phone:** Contact dealer directly\n\n"
+
+    display_text += """### 📊 **All Dealer Rankings**
+"""
+    
+    # Add dealer rankings with contact info using batch lookup results
     for dealer in data["dealer_rankings"]:
         rank_emoji = "🥇" if dealer["rank"] == 1 else "🥈" if dealer["rank"] == 2 else "🥉" if dealer["rank"] == 3 else "🔸"
-        display_text += f"{rank_emoji} **{dealer['rank']}. {dealer['dealer_name']}** - {dealer['confidence_percentage']}\n"
+        dealer_name = dealer['dealer_name']
+        
+        # Get contact info from batch lookup
+        contact_info = all_contacts.get(dealer_name)
+        
+        if contact_info and contact_info.get('phone'):
+            phone_info = f" • 📞 {contact_info['phone']}"
+        else:
+            phone_info = " • 📞 Contact dealer"
+            
+        display_text += f"{rank_emoji} **{dealer['rank']}. {dealer_name}** - {dealer['confidence_percentage']}{phone_info}\n"
     
     display_text += f"""
 
@@ -128,7 +167,7 @@ def simple_predict_dealers_interface(matcher, simple_make, simple_model, simple_
 - Error handling: `success` and `error` fields
 """
     
-    return f"🎯 **Best Match: {top_dealer}**", confidence, display_text
+    return top_dealer_display, confidence, display_text
 
 
 def search_data_interface(matcher, keyword_search, make, model, year_from, year_to, body_type, fuel_type, 
@@ -141,29 +180,51 @@ def search_data_interface(matcher, keyword_search, make, model, year_from, year_
     processed_fuel_type = None if fuel_type == "Select Fuel Type" else fuel_type
     processed_selected_file = None if selected_file == "Select File" else selected_file
     
-    message, result_data = matcher.search_data_files(keyword_search=keyword_search, make=processed_make, 
-                                                     model=processed_model, year_min=None, year_max=None,
-                                                     year_from=year_from, year_to=year_to,
-                                                     body_type=processed_body_type, fuel_type=processed_fuel_type, 
-                                                     max_odometer=None, odometer_from=odometer_from, 
-                                                     odometer_to=odometer_to, max_price=max_price, 
-                                                     selected_file=processed_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"
+    if show_dealer_stats:
+        # Use API method that returns clean structured data
+        api_result = matcher.search_data_files_api(
+            keyword_search=keyword_search, 
+            make=processed_make, 
+            model=processed_model, 
+            year_from=year_from, 
+            year_to=year_to,
+            body_type=processed_body_type, 
+            fuel_type=processed_fuel_type, 
+            odometer_from=odometer_from, 
+            odometer_to=odometer_to, 
+            max_price=max_price, 
+            selected_file=processed_selected_file, 
+            max_results=max_results
+        )
+        
+        if not api_result["success"]:
+            return f"❌ {api_result['message']}", "Error occurred", ""
         
-        return message, info_text, result_data
+        # Apply HTML formatting for UI display
+        try:
+            from utils import format_dealer_results_as_html
+            dealer_html = format_dealer_results_as_html(api_result['data']['dealers'])
+            
+            summary = api_result['data']['search_summary']
+            message = f"✅ Found {summary['total_matches']:,} matches from {summary['original_count']:,} records in {summary['file_searched']}"
+            info_text = "**🏆 Dealer Rankings with Expandable Car Lists**\n\nClick on any dealer name to see their individual car listings with prices and specifications."
+            
+            return message, info_text, dealer_html
+        except ImportError:
+            # Fallback if HTML formatting fails
+            return api_result['message'], "API data available but HTML formatting failed", str(api_result['data'])
     else:
-        # Handle DataFrame case (when show_dealer_stats=False)
-        if hasattr(result_data, 'empty') and not result_data.empty:
+        # For non-dealer stats, use the original method that returns DataFrame
+        message, result_data = matcher.search_data_files(keyword_search=keyword_search, make=processed_make, 
+                                                         model=processed_model, year_min=None, year_max=None,
+                                                         year_from=year_from, year_to=year_to,
+                                                         body_type=processed_body_type, fuel_type=processed_fuel_type, 
+                                                         max_odometer=None, odometer_from=odometer_from, 
+                                                         odometer_to=odometer_to, max_price=max_price, 
+                                                         selected_file=processed_selected_file, 
+                                                         max_results=max_results, show_dealer_stats=False)
+        
+        if isinstance(result_data, pd.DataFrame) 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)
@@ -180,42 +241,223 @@ def simple_search_data_interface(matcher, keyword_search, make, model, year_from
     processed_model = None if (not model or model.strip() == "" or model == "ALL") else model.strip()
     processed_selected_file = None if selected_file == "Select File" else selected_file
     
-    message, result_data = matcher.search_data_files(
+    if show_dealer_stats:
+        # Use API method that returns clean structured data
+        api_result = matcher.search_data_files_api(
+            keyword_search=keyword_search,
+            make=processed_make, 
+            model=processed_model, 
+            year_from=year_from,
+            year_to=year_to,
+            odometer_from=odometer_from,
+            odometer_to=odometer_to,
+            selected_file=processed_selected_file, 
+            max_results=max_results
+        )
+        
+        if not api_result["success"]:
+            return f"❌ {api_result['message']}", "Error occurred", ""
+        
+        # Apply HTML formatting for UI display
+        try:
+            from utils import format_dealer_results_as_html
+            dealer_html = format_dealer_results_as_html(api_result['data']['dealers'])
+            
+            summary = api_result['data']['search_summary']
+            message = f"✅ Found {summary['total_matches']:,} matches from {summary['original_count']:,} records in {summary['file_searched']}"
+            info_text = "**🏆 Dealer Rankings with Expandable Car Lists**\n\nClick on any dealer name to see their individual car listings with prices and specifications."
+            
+            return message, info_text, dealer_html
+        except ImportError:
+            # Fallback if HTML formatting fails
+            return api_result['message'], "API data available but HTML formatting failed", str(api_result['data'])
+    else:
+        # For non-dealer stats, use original method that returns DataFrame
+        message, result_data = matcher.search_data_files(
+            keyword_search=keyword_search,
+            make=processed_make, 
+            model=processed_model, 
+            year_min=None, 
+            year_max=None,
+            year_from=year_from,
+            year_to=year_to,
+            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_from=odometer_from,
+            odometer_to=odometer_to,
+            max_price=None,  # Not used in simple search
+            selected_file=processed_selected_file, 
+            max_results=max_results, 
+            show_dealer_stats=False
+        )
+        
+        if isinstance(result_data, pd.DataFrame) 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 range_search_data_interface(matcher, keyword_search, make, model, year_value, year_range, odometer_value, odometer_range, 
+                               selected_file, max_results, show_dealer_stats):
+    """Interface function for simple range-based data search with slider-controlled ranges and manual text input"""
+    # Handle text inputs - convert empty strings to None for backend processing
+    processed_make = None if (not make or make.strip() == "") else make.strip()
+    processed_model = None if (not model or model.strip() == "") else model.strip()
+    processed_selected_file = None if selected_file == "Select File" else selected_file
+    
+    # Convert target±range to from/to values for the matcher
+    year_from = year_value - year_range if year_value and year_range is not None else None
+    year_to = year_value + year_range if year_value and year_range is not None else None
+    
+    odometer_from = odometer_value - odometer_range if odometer_value and odometer_range is not None else None
+    odometer_to = odometer_value + odometer_range if odometer_value and odometer_range is not None else None
+    
+    if show_dealer_stats:
+        # Use API method that returns clean structured data
+        api_result = matcher.search_data_files_api(
+            keyword_search=keyword_search,
+            make=processed_make, 
+            model=processed_model, 
+            year_from=year_from,
+            year_to=year_to,
+            odometer_from=odometer_from,
+            odometer_to=odometer_to,
+            selected_file=processed_selected_file, 
+            max_results=max_results
+        )
+        
+        if not api_result["success"]:
+            return f"❌ {api_result['message']}", "Error occurred", ""
+        
+        # Apply HTML formatting for UI display
+        try:
+            from utils import format_dealer_results_as_html
+            dealer_html = format_dealer_results_as_html(api_result['data']['dealers'])
+            
+            summary = api_result['data']['search_summary']
+            message = f"✅ Found {summary['total_matches']:,} matches from {summary['original_count']:,} records in {summary['file_searched']}"
+            info_text = "**🏆 Dealer Rankings with Expandable Car Lists**\n\nClick on any dealer name to see their individual car listings with prices and specifications."
+            
+            return message, info_text, dealer_html
+        except ImportError:
+            # Fallback if HTML formatting fails
+            return api_result['message'], "API data available but HTML formatting failed", str(api_result['data'])
+    else:
+        # For non-dealer stats, use original method that returns DataFrame
+        message, result_data = matcher.search_data_files(
+            keyword_search=keyword_search,
+            make=processed_make, 
+            model=processed_model, 
+            year_min=None, 
+            year_max=None,
+            year_from=year_from,
+            year_to=year_to,
+            body_type=None,  # Not used in range search
+            fuel_type=None,  # Not used in range search
+            max_odometer=None,  # Not using max_odometer anymore
+            odometer_from=odometer_from,
+            odometer_to=odometer_to,
+            max_price=None,  # Not used in range search
+            selected_file=processed_selected_file, 
+            max_results=max_results, 
+            show_dealer_stats=False
+        )
+        
+        if isinstance(result_data, pd.DataFrame) 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 range_search_data_interface_api(matcher, keyword_search, make, model, year_value, year_range, odometer_value, odometer_range, 
+                                   selected_file, max_results, show_dealer_stats):
+    """Pure API interface function that returns clean JSON data without HTML formatting"""
+    # Handle text inputs - convert empty strings to None for backend processing
+    processed_make = None if (not make or make.strip() == "") else make.strip()
+    processed_model = None if (not model or model.strip() == "") else model.strip()
+    processed_selected_file = None if selected_file == "Select File" else selected_file
+    
+    # Convert target±range to from/to values for the matcher
+    year_from = year_value - year_range if year_value and year_range is not None else None
+    year_to = year_value + year_range if year_value and year_range is not None else None
+    
+    odometer_from = odometer_value - odometer_range if odometer_value and odometer_range is not None else None
+    odometer_to = odometer_value + odometer_range if odometer_value and odometer_range is not None else None
+    
+    # Always use API method that returns clean structured data
+    api_result = matcher.search_data_files_api(
         keyword_search=keyword_search,
         make=processed_make, 
         model=processed_model, 
-        year_min=None, 
-        year_max=None,
         year_from=year_from,
         year_to=year_to,
-        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_from=odometer_from,
         odometer_to=odometer_to,
-        max_price=None,  # Not used in simple search
         selected_file=processed_selected_file, 
-        max_results=max_results, 
-        show_dealer_stats=show_dealer_stats
+        max_results=max_results
     )
     
-    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", "" 
+    # Return clean JSON data directly - NO HTML formatting
+    return api_result
+
+
+def search_data_interface_api(matcher, keyword_search, make, model, year_from, year_to, body_type, fuel_type, 
+                             odometer_from, odometer_to, max_price, selected_file, max_results, show_dealer_stats):
+    """Pure API interface function that returns clean JSON data without HTML formatting"""
+    # Handle text inputs - convert empty strings to None for backend processing
+    processed_make = None if (not make or make.strip() == "" or make == "Select Make") else make.strip()
+    processed_model = None if (not model or model.strip() == "" or model == "ALL") else model.strip()
+    processed_body_type = None if body_type == "Select Body Type" else body_type
+    processed_fuel_type = None if fuel_type == "Select Fuel Type" else fuel_type
+    processed_selected_file = None if selected_file == "Select File" else selected_file
+    
+    # Always use API method that returns clean structured data
+    api_result = matcher.search_data_files_api(
+        keyword_search=keyword_search, 
+        make=processed_make, 
+        model=processed_model, 
+        year_from=year_from, 
+        year_to=year_to,
+        body_type=processed_body_type, 
+        fuel_type=processed_fuel_type, 
+        odometer_from=odometer_from, 
+        odometer_to=odometer_to, 
+        max_price=max_price, 
+        selected_file=processed_selected_file, 
+        max_results=max_results
+    )
+    
+    # Return clean JSON data directly - NO HTML formatting
+    return api_result
+
+
+def simple_search_data_interface_api(matcher, keyword_search, make, model, year_from, year_to, odometer_from, odometer_to, selected_file, 
+                                    max_results, show_dealer_stats):
+    """Pure API interface function that returns clean JSON data without HTML formatting"""
+    # Handle text inputs - convert empty strings to None for backend processing
+    processed_make = None if (not make or make.strip() == "" or make == "Select Make") else make.strip()
+    processed_model = None if (not model or model.strip() == "" or model == "ALL") else model.strip()
+    processed_selected_file = None if selected_file == "Select File" else selected_file
+    
+    # Always use API method that returns clean structured data
+    api_result = matcher.search_data_files_api(
+        keyword_search=keyword_search,
+        make=processed_make, 
+        model=processed_model, 
+        year_from=year_from,
+        year_to=year_to,
+        odometer_from=odometer_from,
+        odometer_to=odometer_to,
+        selected_file=processed_selected_file, 
+        max_results=max_results
+    )
+    
+    # Return clean JSON data directly - NO HTML formatting
+    return api_result 

ui/tabs/__init__.py

@@ -1 +1,20 @@
-# Tab components for the Gradio interface 
+"""
+UI tab components for the Swiper Match Gradio application
+Contains all tab creation functions for different search interfaces
+"""
+
+# Import all tab creation functions
+from .simple_tab import create_simple_tab
+from .detailed_tab import create_detailed_tab
+from .traditional_tab import create_traditional_tab
+from .simple_search_tab import create_simple_search_tab
+from .range_search_tab import create_range_search_tab
+
+# Define what gets exported when using "from ui.tabs import *"
+__all__ = [
+    'create_simple_tab',
+    'create_detailed_tab',
+    'create_traditional_tab', 
+    'create_simple_search_tab',
+    'create_range_search_tab'
+] 

ui/tabs/range_search_tab.py

@@ -0,0 +1,174 @@
+"""
+Range search tab component for advanced CSV data search with range filtering
+"""
+
+import gradio as gr
+from core.config import CAR_MAKES, MAKE_MODEL_DATA, DEFAULT_VALUES
+
+
+def create_range_search_tab(matcher):
+    """Create the range SQL search tab"""
+    
+    with gr.Tab("3️⃣ Simple Range Search"):
+        gr.Markdown("### Simple Range-Based CSV Data Search")
+        gr.Markdown("Easy search through car listing CSV files with manual text input and flexible range-based filters")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 🗂️ File & Options")
+                file_choices = ["Select File"] + matcher.data_files
+                range_search_file = gr.Dropdown(
+                    choices=file_choices,
+                    label="Select CSV File",
+                    value="Select File",
+                    info=f"Available files: {len(matcher.data_files)}"
+                )
+                
+                range_max_results = gr.Number(
+                    label="Max Results",
+                    value=DEFAULT_VALUES['max_results'],
+                    minimum=1,
+                    maximum=1000,
+                    info="Limit number of results returned"
+                )
+                
+                range_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("### 🔍 Advanced Range Search Filters")
+                
+                # General keyword search
+                range_keyword_search = gr.Textbox(
+                    label="🔍 Keyword Search",
+                    placeholder="Search across all fields (make, model, dealer, location, etc.)",
+                    info="General search across multiple columns"
+                )
+                
+                gr.Markdown("#### Range-Based Filters")
+                
+                with gr.Row():
+                    range_search_make = gr.Textbox(
+                        label="Make",
+                        placeholder="e.g., Toyota, Ford, Honda",
+                        info="Type car manufacturer name"
+                    )
+                    range_search_model = gr.Textbox(
+                        label="Model",
+                        placeholder="e.g., Camry, Focus, Civic",
+                        info="Type car model name"
+                    )
+                
+                with gr.Row():
+                    range_year_value = gr.Number(
+                        label="Target Year",
+                        value=DEFAULT_VALUES['year'],
+                        minimum=1990,
+                        maximum=2025,
+                        info="Target manufacturing year"
+                    )
+                    range_year_range = gr.Slider(
+                        minimum=0,
+                        maximum=10,
+                        value=2,
+                        step=1,
+                        label="Year Range (±years)",
+                        info="Range around target year"
+                    )
+                
+                with gr.Row():
+                    range_odometer_value = gr.Number(
+                        label="Target Odometer (km)",
+                        value=65000,
+                        minimum=0,
+                        info="Target odometer reading"
+                    )
+                    range_odometer_range = gr.Slider(
+                        minimum=0,
+                        maximum=100000,
+                        value=25000,
+                        step=1000,
+                        label="Odometer Range (±km)",
+                        info="Range around target (±km)"
+                    )
+                
+
+        
+        # Simple range search button
+        range_search_btn = gr.Button(
+            "🔍 Search CSV Data (Simple Range)",
+            variant="primary",
+            size="lg"
+        )
+        
+        with gr.Row():
+            # Reset button
+            range_reset_btn = gr.Button(
+                "🔄 Reset to Defaults",
+                variant="secondary",
+                size="sm"
+            )
+        
+        # Range Search Results Section
+        with gr.Row():
+            range_search_status = gr.Textbox(
+                label="🔍 Search Status",
+                interactive=False,
+                lines=2
+            )
+        
+        with gr.Row():
+            range_search_info = gr.Markdown(
+                label="📊 Results Info",
+                value="Click 'Search CSV Data (Simple Range)' to start searching..."
+            )
+        
+        with gr.Row():
+            range_search_results_table = gr.HTML(
+                label="📋 Search Results",
+                value="<p>No search performed yet</p>"
+            )
+        
+        gr.Markdown("""
+        ---
+        ### 🎯 Simple Range Search Features
+        
+        **🔍 Keyword Search:** General search across all text fields (make, model, dealer name, location, etc.)
+        **✍️ Manual Input:** Type make and model names directly - no dropdown limitations
+        **📊 Simple Ranges:** Set target values with flexible range controls using sliders
+        **🎯 Year Range:** Set target year with ± range (e.g., 2020 ± 2 years = 2018-2022)
+        **🎯 Odometer Range:** Set target odometer reading with ± range (e.g., 65,000 ± 25,000 km)
+        **🚀 Easy to Use:** Simplified interface with text inputs for make and model
+        **Dealer Ranking:** Get dealers ranked by inventory matching your criteria
+        **Flexible Input:** Type any make/model combination, not limited to predefined lists
+        **🔄 Reset Button:** Quickly restore all fields to their default values
+        **Flexible Filtering:** Combine multiple range filters for highly targeted results
+        """)
+    
+    def reset_range_search():
+        """Reset all range search fields to default values"""
+        return (
+            "",  # range_keyword_search
+            "",  # range_search_make
+            "",  # range_search_model
+            DEFAULT_VALUES['year'],  # range_year_value
+            2,  # range_year_range
+            65000,  # range_odometer_value
+            25000,  # range_odometer_range
+            "Select File",  # range_search_file
+            DEFAULT_VALUES['max_results'],  # range_max_results
+            True,  # range_show_dealer_stats
+        )
+    
+    return {
+        'inputs': [range_keyword_search, range_search_make, range_search_model, range_year_value, range_year_range, 
+                  range_odometer_value, range_odometer_range, range_search_file, 
+                  range_max_results, range_show_dealer_stats],
+        'outputs': [range_search_status, range_search_info, range_search_results_table],
+        'button': range_search_btn,
+        'reset_button': range_reset_btn,
+        'reset_function': reset_range_search
+    } 

ui/tabs/simple_tab.py

@@ -60,7 +60,7 @@ def create_simple_tab(simple_matcher):
                 simple_top_dealer = gr.Textbox(
                     label="🏆 Top Recommended Dealer",
                     interactive=False,
-                    lines=2
+                    lines=3
                 )
                 simple_confidence = gr.Textbox(
                     label="🎯 Confidence Score",

utils/__init__.py

@@ -1 +1,21 @@
-# Utility functions for the Swiper Match application 
+"""
+Utility functions for the Swiper Match application
+"""
+
+# Import all helper functions and make them available at package level
+from .helpers import (
+    get_model_status_info,
+    get_app_header,
+    get_app_description,
+    setup_event_handlers,
+    format_dealer_results_as_html
+)
+
+# Define what gets exported when using "from utils import *"
+__all__ = [
+    'get_model_status_info',
+    'get_app_header', 
+    'get_app_description',
+    'setup_event_handlers',
+    'format_dealer_results_as_html'
+] 

utils/helpers.py

@@ -57,7 +57,7 @@ def get_app_description():
 
 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
+    simple_tab, detailed_tab, traditional_tab, simple_search_tab, range_search_tab = tabs_data
     matcher, simple_matcher = matchers
     
     # Simple tab click event
@@ -88,6 +88,13 @@ def setup_event_handlers(tabs_data, interface_functions, matchers):
         outputs=simple_search_tab['outputs']
     )
     
+    # Range search click event
+    range_search_tab['button'].click(
+        fn=lambda *args: interface_functions['simple_range_search'](matcher, *args),
+        inputs=range_search_tab['inputs'],
+        outputs=range_search_tab['outputs']
+    )
+    
     # Set up dynamic model updating based on make selection (only for tabs with dropdowns)
     if 'make_dropdown' in detailed_tab and 'model_dropdown' in detailed_tab:
         detailed_tab['make_dropdown'].change(
@@ -104,6 +111,8 @@ def setup_event_handlers(tabs_data, interface_functions, matchers):
             outputs=simple_search_tab['model_dropdown']
         )
     
+    # Range search now uses text inputs instead of dropdowns, so no model update needed
+    
     # Reset buttons
     if 'reset_button' in simple_search_tab:
         simple_search_tab['reset_button'].click(
@@ -117,4 +126,133 @@ def setup_event_handlers(tabs_data, interface_functions, matchers):
             fn=traditional_tab['reset_function'],
             inputs=[],
             outputs=traditional_tab['inputs']
-        ) 
+        )
+    
+    if 'reset_button' in range_search_tab:
+        range_search_tab['reset_button'].click(
+            fn=range_search_tab['reset_function'],
+            inputs=[],
+            outputs=range_search_tab['inputs']
+        ) 
+
+
+def format_dealer_results_as_html(dealer_results):
+    """
+    Format dealer search results as HTML for UI display
+    
+    Args:
+        dealer_results: List of dealer dictionaries with structure:
+        [
+            {
+                "rank": 1,
+                "dealer_name": "Toyota City",
+                "car_count": 25,
+                "contact": {
+                    "phone": "(08) 9999 1234",
+                    "city": "Perth", 
+                    "state": "WA"
+                },
+                "cars": [list of car dictionaries]
+            }
+        ]
+    
+    Returns:
+        str: HTML formatted string for display
+    """
+    if not dealer_results:
+        return "<p>No dealer results to display</p>"
+    
+    html_content = ""
+    
+    for dealer in dealer_results:
+        rank = dealer.get('rank', 0)
+        dealer_name = dealer.get('dealer_name', 'Unknown Dealer')
+        car_count = dealer.get('car_count', 0)
+        contact = dealer.get('contact', {})
+        cars = dealer.get('cars', [])
+        
+        # Create rank emoji
+        rank_emoji = "🥇" if rank == 1 else "🥈" if rank == 2 else "🥉" if rank == 3 else f"#{rank}"
+        
+        # Format dealer header with contact info
+        dealer_header = f"{rank_emoji} {dealer_name} ({car_count} cars)"
+        if contact:
+            if contact.get('phone'):
+                dealer_header += f" • 📞 {contact['phone']}"
+            if contact.get('city') != 'Unknown' and contact.get('state') != 'Unknown':
+                dealer_header += f" • 📍 {contact['city']}, {contact['state']}"
+        
+        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;">
+                {dealer_header}
+            </summary>
+            <div style="margin-top: 10px; max-height: 300px; overflow-y: auto;">
+        """
+        
+        # Add contact information section at the top if available
+        if contact and (contact.get('phone') or 
+            (contact.get('city') != 'Unknown' or contact.get('state') != 'Unknown')):
+            html_content += f"""
+                <div style="padding: 8px; margin: 4px 0; background: #e8f4f8; border-radius: 3px; border-left: 3px solid #007bff;">
+                    <strong>📞 Contact Information</strong><br>
+            """
+            if contact.get('phone'):
+                html_content += f"<small>Phone: {contact['phone']}</small><br>"
+            if contact.get('city') != 'Unknown' or contact.get('state') != 'Unknown':
+                html_content += f"<small>Location: {contact.get('city', 'Unknown')}, {contact.get('state', 'Unknown')}</small>"
+            html_content += "</div>"
+        
+        # Add individual cars (limit to first 20)
+        displayed_cars = cars[:20]
+        for car in displayed_cars:
+            make = car.get('make', 'Unknown')
+            model = car.get('model', 'Unknown')
+            year = car.get('year', 'Unknown')
+            price = car.get('price', 'Unknown')
+            odometer = car.get('odometer', 'Unknown')
+            body_type = car.get('body_type', 'Unknown')
+            fuel_type = car.get('fuel_type', 'Unknown')
+            transmission = car.get('transmission', 'Unknown')
+            
+            # Format price
+            if price != 'Unknown' and price is not None:
+                try:
+                    price_str = f"${int(float(price)):,}"
+                except:
+                    price_str = "Price on request"
+            else:
+                price_str = "Price on request"
+            
+            # Format odometer
+            if odometer != 'Unknown' and odometer is not None:
+                try:
+                    odometer_str = f"{int(float(odometer)):,} km"
+                except:
+                    odometer_str = "Unknown km"
+            else:
+                odometer_str = "Unknown km"
+            
+            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 cars than displayed
+        total_cars = dealer.get('total_cars', len(cars))
+        if total_cars > len(cars):
+            remaining_cars = total_cars - len(cars)
+            html_content += f"""
+                <div style="padding: 8px; margin: 4px 0; background: #e9ecef; border-radius: 3px; text-align: center; font-style: italic;">
+                    ... and {remaining_cars} more cars
+                </div>
+            """
+        
+        html_content += """
+            </div>
+        </details>
+        """
+    
+    return html_content